fix(graph_sqlite): fix ExpandFromResults - wrong field access + Chinese entity extraction

Root causes fixed:
1. ExpandFromResults accessed p["to"] but SQLiteGraphStore.Navigate
   returns {"source","target","relation","weight"} - field name mismatch
   caused graph expansion to always return empty
2. Original logic checked seen[r.ID] (memory ID) against entity name
   (neighbor string), which never matched - removed stale logic

Also improved extractPotentialEntities:
- Now handles Chinese continuous character sequences (2-8 chars)
- Chinese entities extracted as whole words, not split by spaces
- English capitalized words preserved with original casing

Changes:
- ExpandFromResults: correct field access (source/target/relation),
  bidirectional neighbor detection (forward + reverse edges),
  separate seenEntities map for entity dedup
- extractPotentialEntities: full rewrite for Chinese + better English
  word tokenization without space-based splitting

.git_commit_msg_t357c5.txt

@@ -1,14 +0,0 @@
-fix(provenance): 落库 embedding_model/script_version 血缘字段 (t_7e3577c5)
-
-根因: commit→distill→memory 管线从不在服务端持久化请求 metadata 里的
-embedding_model/script_version, MemoryRecord 结构缺这两字段, 导致
-zhiyi-vault-ingest.py 已发送的血缘被丢弃, 新写入恒 NULL。
-
-修复:
-- Go MemoryRecord + DistillInput 加两字段;
-  core.go commit handler 解析 metadata→AutoDistillTrigger 透传;
-  server.go 落库时 orDefault(embedding_model→bge-m3, script_version→unknown);
-  lancedb_ipc.go 记录 map 带上两字段。
-- Rust MemoryRecord + arrow_schema() + insert_batch + 4 处 col_str 读取。
-
-验证: commit 带 metadata → 蒸馏落地 19 行 bge-m3/vault-ingest-2.0.0 (原为 NULL)。

.gitignore

@@ -30,11 +30,3 @@ __pycache__/
 .venv/
 backups/
 go/build.sh
-plugins/obsidian/node_modules/
-bin/
-# 构建产物（worker 曾把 7.9M 二进制留在工作区，2026-09-21）
-go/zhiyi-cli
-go/zhiyid
-
-# 临时工件（cron list dump，随时可 `hermes cron list` 重现，不入库）
-cron_raw.txt

CREATIVE.md

@@ -1,5 +0,0 @@
-# CREATIVE.md — 织忆(A06) 工作记忆与学习状态
-> 由 Hermes 织忆插件自动管理
-> 创建日期：2026-07-02
-
-<!-- 织忆自动管理 — 请勿手动编辑 -->

DESIGN-v2-llm-optimizer.md

@@ -1,379 +0,0 @@
-# 织忆 v2 — LLM 驱动的自优化系统
-
-> 版本：v2.0.0-draft
-> 状态：待评审
-> 基于：v1.0.0-stable
-
----
-
-## 1. 背景与目标
-
-### 1.1 现状问题
-
-v1 版本中，织忆各个模块（distill、consolidate、recall）各自为政，没有全局感知和自主优化能力：
-
-```
-commit → distill（被动，一次一条）
-     ↓
-consolidate（定时，固定流程，不感知状态）
-     ↓
-质量回溯（采样20条，不闭环）
-     ↓
-recall（独立系统）
-```
-
-**核心矛盾**：LLM 没有被用来管理织忆，参数全靠手设，异常靠牧尘发现。
-
-### 1.2 升级目标
-
-1. **LLM 全局巡检** — 主动发现全流程堵点和异常
-2. **参数自动调优** — 基于指标自动调整，无需手设
-3. **Hermes 监督汇报** — 我执行操作，牧尘知情，重大决策上报
-4. **可回滚** — 任何时候可切回 v1.0.0-stable
-
-### 1.3 设计原则
-
-| 原则 | 说明 |
-|---|---|
-| 成本优先 | 无异常不调用 LLM，用指标驱动触发 |
-| 我执行 | LLM 发现/建议，我执行操作，不让它直连数据 |
-| 可观测 | 每次决策记录 JSONL + git commit |
-| 轻量触发 | 规则引擎处理常见情况，LLM 只处理复杂因果 |
-
----
-
-## 2. 系统架构
-
-### 2.1 角色分工
-
-```
-┌─────────────────────────────────────────────────────┐
-│  织忆 v2 独立部署包（可部署在其他机器）               │
-│                                                     │
-│  ┌─────────────────────────────────────────────┐   │
-│  │  LLM Agent（独立运行，不依赖 Hermes）         │   │
-│  │  ├─ 自己的 cronjob（每 60 分钟自检）          │   │
-│  │  ├─ 规则引擎：自动调参                       │   │
-│  │  ├─ LLM 巡检：复杂因果自主决策               │   │
-│  │  └─ 自主调用织忆 API 执行操作                │   │
-│  └─────────────────────────────────────────────┘   │
-│                                                     │
-│  决策日志 → git commit → 飞书通知牧尘              │
-└─────────────────────────────────────────────────────┘
-          ↓（飞书通知，仅重大决策）
-┌─────────────────────────────────────────────────────┐
-│  Hermes（可选，不参与运行）                         │
-│  ├─ 旁听重大决策（飞书收到通知）                    │
-│  └─ 牧尘可通过 Hermes 转发指令给 LLM Agent          │
-└─────────────────────────────────────────────────────┘
-```
-
-### 2.2 独立性设计
-
-LLM Agent 脱离 Hermes 独立运行的关键点：
-- 自己的定时器（systemd timer 或 cronjob）
-- 自己持有织忆 API 地址和认证
-- 自己管理 LLM API（可独立配置模型和端点）
-- 飞书机器人直接通知牧尘，不经过 Hermes 中转
-- 部署时只需修改配置文件，无需改动 Hermes
-
-### 2.3 与 v1 的关系
-
-- v1 的各个 API 和逻辑保持不变，作为执行层
-- v2 在 v1 之上加了一层"调度 + 巡检"逻辑
-- v2 的调度器用 cronjob 实现，调用 v1 的已有 API
-
----
-
-## 3. 触发机制
-
-### 3.1 指标驱动（非定时）
-
-每 60 分钟读取一次状态（现有 cronjob `织忆状态看板`），判断是否触发巡检：
-
-| 触发条件 | 说明 |
-|---|---|
-| recall 命中率连续 2 次下降 | 需要巡检 recall 质量 |
-| gap_detected 堆积 > 5 条未处理 | 需要巡检 recall gap |
-| distill 队列积压 > 20 条 | 需要巡检 distill 瓶颈 |
-| consolidate 质量分 < 0.6 | 需要巡检聚类/质量回溯 |
-| 冲突堆积 > 3 条 | 需要巡检冲突处理 |
-| 规则引擎连续 3 次调参无效 | 需要 LLM 分析复杂因果 |
-
-**无异常时完全不调用 LLM**，不花额外费用。
-
-### 3.2 手动触发
-
-牧尘可以随时说"巡检织忆"，我会立即执行一次完整巡检。
-
----
-
-## 4. 参数自动调优
-
-### 4.1 参数列表
-
-| 参数 | 位置 | 默认值 | 正常范围 | 调整粒度 |
-|---|---|---|---|---|
-| `dbscan_epsilon` | consolidate | 0.5 | 0.3–1.5 | ±0.1 |
-| `dbscan_min_points` | consolidate | 3 | 2–10 | ±1 |
-| `decay_rate` | tuning.go | 0.015 | 0.005–0.05 | 乘/除 1.2 |
-| `gap_threshold` | tuning.go | 3 | 1–10 | ±1 |
-| `consolidate_after` | tuning.go | 50 | 20–200 | ±10 |
-| `prune_threshold` | consolidation_pipe.go | 0.15 | 0.05–0.5 | ±0.05 |
-
-### 4.2 规则引擎调参（无需 LLM）
-
-规则引擎根据指标直接调整参数：
-
-```
-IF recall 命中率下降 AND noise_points > 总数 30%:
-  → epsilon += 0.1
-
-IF gap 堆积 > 5 AND gap_threshold 连续 2 次调低无效:
-  → 触发 LLM 巡检
-
-IF distill 质量分下降 AND decay_rate 最近 7 天内未调:
-  → decay_rate /= 1.2
-
-IF 修剪节点数 / 总节点数 > 20%:
-  → prune_threshold += 0.05
-```
-
-### 4.3 LLM 辅助调参
-
-规则引擎遇到复杂因果时，调用 LLM：
-
-```
-触发条件：规则引擎连续 3 次调参后指标未改善
-输入：系统手册 + 当前指标快照 + 调参历史 + 异常事件
-LLM 输出：
-  {
-    "analysis": "根因分析",
-    "action": "调参 / 重蒸 / 合并 / 其他",
-    "parameters": { "epsilon": 0.6 },
-    "reason": "..."
-  }
-```
-
-### 4.4 调参执行流程
-
-```
-规则引擎判断需要调参
-     ↓
-读取当前参数值
-     ↓
-应用调整（写入 tuning.go 或调用 API）
-     ↓
-记录到 llm-tuning-log.jsonl
-     ↓
-git commit "llm-tune: epsilon 0.5→0.6"
-     ↓
-下次指标采样时判断是否生效
-```
-
----
-
-## 5. LLM 系统手册
-
-### 5.1 手册内容
-
-触发 LLM 巡检时，注入以下上下文：
-
-```
-你是织忆记忆系统的巡检员，负责发现全流程的堵点和异常。
-
-【系统架构】
-- distill：记忆蒸馏，commit 时被动触发，将长对话压缩为记忆
-- consolidate：记忆整合，定时（DBSCAN 聚类 + 剪枝 + 衰减校准 + 质量回溯）
-- recall：记忆召回，查询时向量检索
-- graph：图谱管理，实体/关系/冲突
-
-【参数说明】
-- dbscan_epsilon：聚类半径，影响聚类数量和 noise 比例
-- dbscan_min_points：最小点数，影响核心点判定
-- decay_rate：遗忘衰减率，值越大记忆衰减越快
-- gap_threshold：recall gap 感测阈值，连续 N 次 miss 才记录
-- prune_threshold：图谱剪枝权重阈值
-
-【正常范围】
-- recall 命中率 > 70%
-- noise_points / 总数 < 20%
-- distill 质量分 > 0.6
-- gap 堆积 < 5 条
-- 冲突 < 3 条堆积
-
-【约束】
-- 不要轻易触发全量重蒸，成本高
-- 优先用规则调参，复杂情况才用 LLM
-- 每次操作记录到 /home/muc/projects/memoryweave/ops/llm-tuning-log.jsonl
-
-【当前状态】
-{timestamp}
-{metrics_snapshot}
-{recent_events}
-调参历史：{tuning_history}
-```
-
-### 5.2 手册存放位置
-
-```
-/home/muc/projects/memoryweave/ops/ops-manual.md
-```
-
----
-
-## 6. 决策日志
-
-### 6.1 日志格式（JSONL，每行一条）
-
-```json
-{"ts":"2026-06-09T03:00:00Z","type":"parameter_tune","param":"dbscan_epsilon","old":"0.5","new":"0.6","reason":"recall命中率下降，noise>30%","trigger":"rule_engine","result":"pending","model":"minimaxai/minimax-m2.7"}
-{"ts":"2026-06-09T04:00:00Z","type":"llm_inspection","trigger":"gap堆积>5","analysis":"根因是gap_threshold设置过低","actions":["gap_threshold+=1"],"model":"minimaxai/minimax-m2.7"}
-```
-
-### 6.2 文件位置
-
-```
-/home/muc/projects/memoryweave/ops/llm-tuning-log.jsonl
-```
-
-### 6.3 Git 版本化
-
-每次有决策写入后，提交一次：
-
-```bash
-git add ops/llm-tuning-log.jsonl
-git commit -m "llm-tune: epsilon 0.5→0.6 (recall下降触发)"
-```
-
----
-
-## 7. LLM Agent 的运行方式
-
-### 7.1 自主 Loop（独立于 Hermes）
-
-LLM Agent 独立运行，通过 systemd timer 每 60 分钟自检：
-
-```
-systemd timer（每 60 分钟）:
-  ├─ 读取指标（/api/v1/stats）
-  ├─ 规则引擎判断
-  │   └─ 可处理 → 自动调参 → 记录日志
-  │   └─ 复杂因果 → 调用 LLM 巡检
-  └─ LLM 巡检结果 → 执行操作 → 记录日志
-     └─ 重大决策 → 飞书机器人直接通知牧尘
-```
-
-### 7.2 飞书直接通知牧尘
-
-LLM Agent 拥有自己的飞书机器人，重大决策不经过 Hermes 直接通知牧尘：
-
-| 决策类型 | 是否通知 |
-|---|---|
-| 小调参（epsilon ±0.1） | ❌ 静默 |
-| 正常调参（decay_rate ±20%） | ❌ 静默 |
-| 大幅调参（decay_rate ±50%以上） | ✅ 飞书通知 |
-| 触发全量重蒸 | ✅ 飞书通知 |
-| 连续 3 次调参无效 | ✅ 飞书通知 |
-| 发现系统性问题（distill 质量持续下降） | ✅ 飞书通知 |
-
-### 7.3 汇报格式（飞书）
-
-```
-🤖 织忆 LLM 巡检报告
-
-时间：2026-06-09 08:00
-发现问题：recall 命中率下降至 62%，连续 2 次调参无效
-分析：根因是 DBSCAN epsilon 过小，导致记忆碎片化
-操作：epsilon 0.5→0.7，触发 consolidate full
-建议：观察 3 天，如未改善考虑扩大 rerank 范围
-```
-
-### 7.4 Hermes 的位置
-
-Hermes 不参与 LLM Agent 的运行，只在以下场景介入：
-- 牧尘通过飞书问 Hermes "织忆最近怎么了"→ Hermes 查询日志回答
-- 牧尘让 Hermes "帮看看织忆的状态"→ Hermes 调用 LLM Agent 的状态 API
-- LLM Agent 通知牧尘后，牧尘追问 Hermes → Hermes 解读
-
----
-
-## 8. 回滚机制
-
-### 8.1 回滚到 v1
-
-```bash
-cd /home/muc/projects/memoryweave
-git checkout v1.0.0-stable
-git reset --hard
-systemctl --user restart zhiyid
-```
-
-### 8.2 v1.0.0-stable 内容
-
-```
-commit: fix: add clusters_found/noise_points/quality_score to consolidate API
-tag: v1.0.0-stable
-```
-
-### 8.3 v2 开发分支
-
-```
-主开发分支：main（当前）
-v1 稳定版：v1.0.0-stable（tag）
-v2 发布后打 tag：v2.0.0-stable
-```
-
----
-
-## 9. 实施计划
-
-### Phase 1：日志基础设施（v2 前置）
-- 创建 `ops/llm-tuning-log.jsonl`
-- 创建 `ops/ops-manual.md`
-- 实现 git commit 封装
-
-### Phase 2：LLM Agent Loop
-- 实现 cronjob 驱动的自主巡检
-- 实现规则引擎自动调参
-- 实现 JSONL 写入 + git commit
-
-### Phase 3：Hermes 旁听汇报
-- 实现飞书重大决策上报
-- 实现牧尘手动巡检入口（飞书 → Hermes → LLM Agent）
-
----
-
-## 10. 待确认问题
-
-1. **调参上限** — LLM 一次调整不超过一个参数，幅度不超过 ±50% ✅
-2. **手动巡检入口** — 牧尘说"巡检织忆"→ LLM Agent 自己的飞书机器人直接响应 ✅
-3. **LLM Agent 用的模型** — 和织忆共用同一个 LLM API（`LLM_ENDPOINT` / `LLM_MODEL` 环境变量）✅
-
----
-
-## 11. 实施计划
-
-### Phase 1：日志基础设施（v2 前置）
-- 创建 `ops/llm-tuning-log.jsonl`
-- 创建 `ops/ops-manual.md`
-- 创建 `ops/llm-agent/` 目录（LLM Agent 代码）
-- 实现 git commit 封装
-
-### Phase 2：LLM Agent 独立服务
-- 实现 systemd timer + service
-- 实现指标读取 + 规则引擎调参
-- 实现 LLM 巡检调用
-- 配置独立飞书机器人
-
-### Phase 3：部署独立运行
-- 配置文件（织忆 API 地址、LLM 端点、飞书机器人）
-- 部署在其他机器上验证
-- 验证脱离 Hermes 自主运行
-
----
-
-*文档状态：已保存，待将来需要时实现 v2*
-
-> **状态说明**：v2 方案已完整设计，但因当前织忆运行正常、规模不大，暂不实现。先用监控报警最小闭环。
-> 需要时执行：`git checkout main && cat DESIGN-v2-llm-optimizer.md`

DESIGN.md

@@ -5,7 +5,7 @@
 > **代码生成工具**：opencode
 > **定位**：Hermes / OpenClaw / 未来 Agent 的统一记忆基础设施
 > **修订日期**：2026-05-28
-> **状态**：v3.8 部分实施（共享记忆层 ✅，其他规划中）
+> **状态**：方案锁定，待实施
 
 ---
 
@@ -122,17 +122,6 @@ L3: World Model   — 系统运行环境的心智模型（ℰ/ℐ/C 三元组）
 
 **Agent 注册**：所有 Agent 首次连接织忆时必须调用 `POST /api/v1/agents/register`，系统自动分配 API Key、速率配额、WebSocket 端点，并加入 shared namespace 广播列表。
 
-**原始会话 vs 语义记忆（v3.8 实施澄清）**：
-
-| 数据层 | 存储位置 | 是否共享 |
-|--------|---------|---------|
-| 原始会话（JSONL） | Hermes: `~/.hermes/sessions/`<br>OpenClaw: `~/.openclaw/workspace/sessions/` | ❌ 各自独立 |
-| 语义记忆（L1 蒸馏） | `/var/lib/memoryweave/memories.lance` | ✅ 共享（agent_id 区分） |
-| 知识图谱 | `/var/lib/memoryweave/graph.db` | ✅ 共享（namespace 隔离） |
-| 片段摘要（L0） | `/var/lib/memoryweave/episodes.lance` | ✅ 共享（agent_id 区分） |
-
-织忆是**语义记忆共享层**，不是行为日志聚合层。各 Agent 的原始会话由各自平台管理，织忆只负责从中提取、蒸馏、存储有价值的语义记忆。
-
 
 ## Part 2：存储与检索
 
@@ -1555,47 +1544,91 @@ trigger.max_consecutive_failures: 3
 - **v3.5**：行业对标完成（评估框架+V值+三层语义去重+8类触发器+Skill+L3）
 - **v3.6**：缺口自动分类+记忆预取+溯源链
 - **v3.7**：文档重组（24 章按功能域聚类，消除重复）
-- **v3.8（当前，部分实施）**：完整重写。知识图谱完整设计（5 节全 Schema+来源+算法+修剪+隔离）+ 5 个自动化流程 + Go↔Rust IPC + 被动验证 + 全部 API 端点 + WebSocket 事件类型 + 配置默认值 + 分阶段实施 + vLLM 部署细节 + Consolidation 完整设计。Go（API/业务）+ Rust（LanceDB/BGE/聚类/整合）。**v3.8 共享记忆层已实施**（2026-05-28）：Hermes + OpenClaw 共用 `/var/lib/memoryweave/` LanceDB，原始会话分开存储。
-- **v3.9**：统一记忆架构 ~~待实施~~ → **已实施（共享层）**。Hermes（hermes-lance） + OpenClaw（openclaw lancedb） + 织忆（MemoryWeave SQLite）三系统统一为织忆后端，消除三方记忆孤岛。原始会话仍各自存储。
+- **v3.8（当前）**：完整重写。知识图谱完整设计（5 节全 Schema+来源+算法+修剪+隔离）+ 5 个自动化流程 + Go↔Rust IPC + 被动验证 + 全部 API 端点 + WebSocket 事件类型 + 配置默认值 + 分阶段实施 + vLLM 部署细节 + Consolidation 完整设计。Go（API/业务）+ Rust（LanceDB/BGE/聚类/整合）。Python 完全移除
+- **v3.9**：统一记忆架构。Hermes（hermes-lance） + OpenClaw（openclaw lancedb） + 织忆（MemoryWeave SQLite）三系统统一为织忆后端，消除三方记忆孤岛。
 
-### Appendix E: 统一记忆架构（v3.8 实施完成）
+### Appendix E: 统一记忆规划（v3.9）
 
-#### E.1 实施状态
+#### E.1 当前状态
 
-✅ **已完成（2026-05-28）**：Hermes + OpenClaw 已统一接入织忆后端，共享语义记忆层。
+三个系统各自维护向量记忆：
 
-#### E.2 当前架构
+| 系统 | 后端 | 向量维度 | 数据位置 |
+|------|------|---------|---------|
+| Hermes | hermes-lance (LanceDB) | 1024 | `~/.hermes/data/lance/` |
+| OpenClaw | openclaw lancedb (LanceDB) | 1024 | `~/.openclaw/data/lancedb/` |
+| 织忆 | MemoryWeave SQLite + CGO | 1024 | `/var/lib/zhiyi/data/memoryweave.db` |
+
+问题：
+- Hermes 和 OpenClaw 各自维护独立记忆，互不共享
+- 织忆无法直接读取 Hermes/OpenClaw 的记忆
+- 牧尘对 Hermes 说的话，OpenClaw 不知道
+
+#### E.2 目标
+
+**单一记忆源**：Hermes 和 OpenClaw 不再各自存储记忆，统一走织忆 API。
 
 ```
-┌─────────────────────────────────────────────────────────┐
-│              /var/lib/memoryweave/（共享）              │
-│   memories.lance │ graph.db │ episodes.lance │ tombstones │
-│        ↑              ↑            ↑               ↑     │
-└────────┼──────────────┼───────────┼───────────────┼────────┘
-         │              │           │               │
-    agent_id=      namespace   agent_id=      (软删除
-    hermes-a06     shared      openclaw         标记)
-         ↑                       ↑
-    Hermes Bridge           OpenClaw Memory
-    ~/.hermes/plugins/        ZhiYi Plugin
-    zhiyi/                   ~/.openclaw/workspace/
-                              plugins/memory-zhiyi/
+Hermes ──→ 织忆 Client (ZHIYI_URL=http://localhost:7821) ──→ MemoryWeave SQLite
+OpenClaw ──→ 织忆 Client ────────────────────────────────→ (同一 DB)
 ```
 
-**原始会话（各自独立，不走织忆）：**
-- Hermes: `~/.hermes/sessions/`（飞书消息 JSONL）
-- OpenClaw: `~/.openclaw/workspace/sessions/`（代码任务 JSONL）
+#### E.3 实施步骤
 
-#### E.3 agent_id 分布
+**Phase 1: 配置切换（零代码改动）**
 
-| 系统 | agent_id | namespace | 路径 |
-|------|----------|-----------|------|
-| Hermes | `hermes-a06` | `""`（空） | `~/.hermes/sessions/` |
-| OpenClaw | `openclaw` | `openclaw-main` | `~/.openclaw/workspace/sessions/` |
+Hermes 和 OpenClaw 的 commit/recall 调用改走织忆：
 
-#### E.4 回退策略
+```yaml
+# Hermes: ~/.hermes/config.yaml
+memory:
+  provider: zhiyi
+  zhiyi_url: http://localhost:7821
+  zhiyi_api_key: ${API_KEY}
+  fallback_to_local: true  # 织忆不可用时回退到本地 hermes-lance
+```
 
-若织忆宕机，Hermes/OpenClaw 各自使用本地缓存（fallback）继续运行。恢复后自动重新同步。
+```json
+// OpenClaw: openclaw.json
+{
+  "memory": {
+    "backend": "zhiyi",
+    "zhiyi_url": "http://localhost:7821",
+    "api_key": "zhiyi-dev-key-2026"
+  }
+}
+```
+
+**Phase 2: 双写迁移**
+
+织忆启动时扫描 Hermes/OpenClaw 现有数据并导入：
+
+```bash
+zhiyid --migrate-hermes=/home/muc/.hermes/data/lance
+zhiyid --migrate-openclaw=/home/muc/.openclaw/data/lancedb
+```
+
+迁移完成后，Hermes/OpenClaw 的本地记忆目录标记为只读备份。
+
+**Phase 3: 移除本地存储**
+
+Hermes 和 OpenClaw 移除本地 LanceDB 依赖，纯客户端模式。织忆成为唯一记忆源。
+
+#### E.4 API 兼容性
+
+织忆已完全实现 Hermes/OpenClaw 原有接口的超集：
+
+| Hermes 接口 | 织忆接口 | 状态 |
+|------------|---------|------|
+| memory.save() | POST /api/v1/commit | ✅ |
+| memory.search() | POST /api/v1/recall | ✅ |
+| memory.delete() | DELETE /api/v1/distilled/{id} | ✅ |
+| memory.bootstrap() | GET /api/v1/bootstrap | ✅ |
+| memory.feedback() | POST /api/v1/feedback/* | ✅ |
+
+#### E.5 回退策略
+
+织忆进程宕机时，Hermes/OpenClaw 自动回退到本地 LanceDB（`fallback_to_local: true`）。恢复后自动同步差异数据。
 
 ---
 

G7-IMPLEMENTATION.md

@@ -1,154 +0,0 @@
-# G7: 遗忘 + 技能系统 — 实施计划
-
-> 核心理念：记忆是原料，Hermes skill 是执行体，Bayesian 是裁判，三者构成自举循环。
-
-## 现状
-
-| 组件 | 状态 | 说明 |
-|------|------|------|
-| Forgetter | ✅ 完成 | E4.3 刚修好 |
-| BayesianSkillManager | ✅ 存在 | Beta-Bernoulli 模型，纯内存 |
-| SkillManager | ✅ 存在 | List/Trial API，纯内存 |
-| Skill 持久化 | ❌ | 重启丢失 |
-| Skill 生成 | ❌ | 无自动从记忆生成机制 |
-| Skill 执行 | ❌ | 无 execute API |
-
-## 目标架构
-
-```
-[高质量记忆] --distill/高频recall--> [Skill候选]
-                                        |
-                               [LLM结晶：生成prompt模板]
-                                        |
-[Skill执行成功] <--execute-- [Hermes Skill 执行]
-      |                                   |
-      |            [trial反馈]            |
-      v                                   |
-[Bayesian更新ETA] ────────────> [ETA>0.8: active]
-                                        |
-                              [active skill → 关联记忆 degree+5]
-                                        |
-                              [ETA<0.5: retired → decay_rate×1.2]
-```
-
-## 阶段划分
-
-### G7.1 — 技能持久化（基础）
-
-**扩展 BetaSkill**（`skill_bayes.go`）：
-- 新增字段：`PromptTemplate string`、`LinkedMemoryIDs []string`、`LinkedEntities []string`、`CreatedAt time.Time`
-- 新增 Redis HSET：`zhiyi:skills` → `{name: json(BetaSkill)}`
-
-**扩展 BayesianSkillManager**（`skill_bayes.go`）：
-- `EnableRedisPersistence()` — 启动时从 Redis 加载，重启不丢
-- `persistSkill(skill)` — 每次 RecordTrial 后同步写 Redis
-- `LoadFromRedis()` — 启动时加载所有 skill
-
-**新增 API**（`skill_crud.go`）：
-- `POST /api/v1/skills` — 手动注册新 skill（含 prompt_template）
-- `GET /api/v1/skills/{name}` — 获取单个 skill 详情
-- `DELETE /api/v1/skills/{name}` — 删除 skill
-
-**文件变更**：
-- `go/internal/api/routes/skill_bayes.go` — 扩展结构体 + 持久化
-- `go/internal/api/routes/skill_crud.go` — 新建，CRUD API
-
-### G7.2 — 技能生成（LLM 结晶）
-
-**新增 `skill_crystallize.go`**：
-- `CrystallizeFromMemory(mem *MemoryRecord) (*BetaSkill, error)` — 将高质量记忆转为 skill
-  - 调用 LLM 生成 prompt 模板（从 content 提取参数占位符）
-  - 从 content 提取关键实体作为 LinkedEntities
-- `SuggestSkillCandidates(limit int) []*MemoryRecord` — 找出适合结晶的记忆
-  - 条件：`recall_count >= 5` AND `quality_score >= 0.7` AND `tier != "core"` AND 未关联任何 skill
-
-**Consolidation 集成**（`consolidation_pipe.go`）：
-- 每次 consolidation 后，对候选记忆调用 `CrystallizeFromMemory`
-
-**新增 API**：
-- `POST /api/v1/skills/crystallize` — 手动触发结晶
-- `GET /api/v1/skills/candidates` — 查看当前候选列表
-
-**LLM Prompt（生成 prompt 模板）**：
-```
-给定记忆内容，生成一个可执行的 prompt 模板：
-1. 识别记忆中的可变参数，用 {param} 格式标注
-2. 生成一段可直接执行的指令文本
-3. 提取 3-5 个关键实体作为关联实体
-记忆内容：{content}
-```
-
-### G7.3 — 技能执行 + 反馈闭环
-
-**执行 API**（`skill_execute.go`）：
-- `POST /api/v1/skills/{name}/execute`
-  - Body: `{"params": {"key": "value"}, "context": "optional context override"}`
-  - 加载 linked memories 作为 context
-  - 调用 Hermes agent（`delegate_task`）执行 prompt
-  - 返回执行结果
-
-**与 BayesianSkills 联动**：
-- 执行成功 → `BayesianSkills.RecordTrial(name, true)`
-- 执行失败 → `BayesianSkills.RecordTrial(name, false)`
-  - 若 `ETA < 0.5`：对 linked memories 的 decay_rate ×1.2（加速遗忘）
-
-**与遗忘联动**：
-- `admin.go` Forget 函数扩展：
-  - 扫描记忆时，检查是否有 active skill 关联
-  - 若有关联且 skill.ETA > 0.8：degree +5
-  - 若有关联且 skill.ETA < 0.5：decay_rate ×1.2
-
-**新增 API**：
-- `POST /api/v1/skills/{name}/execute` — 执行 skill
-
-## 技术细节
-
-### Redis Schema
-
-```
-zhiyi:skills        → HASH {skill_name: JSON(BetaSkill)}
-zhiyi:skill_meta    → HASH {skill_name: JSON(SkillMeta)}  # LinkedMemoryIDs, LinkedEntities
-```
-
-### BetaSkill 扩展结构
-
-```go
-type BetaSkill struct {
-    Name             string    `json:"name"`
-    Alpha            float64   `json:"alpha"`
-    Beta             float64   `json:"beta"`
-    Trials           int       `json:"trials"`
-    Successes        int       `json:"successes"`
-    ETA              float64   `json:"eta"`
-    Status           string    `json:"status"`  // active / probation / retired
-    LastUpdated      time.Time `json:"last_updated"`
-    // G7 新增
-    PromptTemplate   string    `json:"prompt_template,omitempty"`
-    LinkedMemoryIDs  []string  `json:"linked_memory_ids,omitempty"`
-    LinkedEntities   []string  `json:"linked_entities,omitempty"`
-    CreatedAt        time.Time `json:"created_at"`
-}
-```
-
-## 验证计划
-
-1. **G7.1 验证**：注册 skill → 重启 Go API → skill 仍在 Redis
-2. **G7.2 验证**：POST `/api/v1/skills/crystallize` → skill 生成，prompt_template 非空
-3. **G7.3 验证**：
-   - `POST /api/v1/skills/{name}/execute` → 返回执行结果
-   - trial 反馈 → Bayesian ETA 更新
-   - ETA > 0.8 → linked memory 保护性增强
-
-## 文件清单
-
-| 文件 | 操作 | 说明 |
-|------|------|------|
-| `go/internal/api/routes/skill_bayes.go` | 修改 | 扩展结构体 + Redis 持久化 |
-| `go/internal/api/routes/skill_crud.go` | 新建 | CRUD API |
-| `go/internal/api/routes/skill_execute.go` | 新建 | 执行 API + 反馈闭环 |
-| `go/internal/api/routes/skill_crystallize.go` | 新建 | LLM 结晶逻辑 |
-| `go/internal/api/server.go` | 修改 | 注册新路由 |
-
-## 实施顺序
-
-1. G7.1（持久化）→ 2. G7.2（生成）→ 3. G7.3（执行+联动）

IMPLEMENTATION-FIVE.md

@@ -1,6 +1,6 @@
 # 织忆五步实施计划
 > 创建时间：2026-05-30
-> 状态：E1/E2/E3/E4/E5 全部完成 ✅
+> 状态：规划阶段，未开始
 > 禁止：偷懒、随意更改变动设计语言
 
 ---
@@ -9,10 +9,10 @@
 
 | 阶段 | 内容 | 优先级 | 预计工期 | 状态 |
 |------|------|--------|---------|------|
-| **E1** | 图谱导航激活 | 🔴 高 | 1-2 天 | ✅ 完成 |
-| **E2** | 多 agent 命名空间激活 | 🔴 高 | 1 天 | ✅ 完成 |
-| **E3** | 增量 embedding | 🟡 中 | 1 天 | ✅ 完成 |
-| **E4** | 图谱推理 | 🟡 中 | 2-3 天 | ✅ 完成 |
+| **E1** | 图谱导航激活 | 🔴 高 | 1-2 天 | ⏳ |
+| **E2** | 多 agent 命名空间激活 | 🔴 高 | 1 天 | ⏳ |
+| **E3** | 增量 embedding | 🟡 中 | 1 天 | ⏳ |
+| **E4** | 图谱推理 | 🟡 中 | 2-3 天 | ⏳ |
 | **E5** | 产品 UI | 🔵 低 | 长期 | ⏳ |
 
 ---
@@ -67,38 +67,63 @@ curl "http://localhost:7821/api/v1/recall?query=织忆图谱导航&top_k=5"
 ### 目标
 Hermes 和 OpenClaw 使用独立 namespace，数据物理隔离，互不串味。
 
-### 现状（2026-05-31 验证）
-- ✅ Hermes：`agent_id="hermes-a06"` → `namespace="hermes-main"`（Go `deriveNamespace` 自动推导）
-- ✅ OpenClaw：`agent_id="openclaw"`，`namespace="openclaw-main"`（zhiyi client 显式传递）
-- ✅ Rust sidecar：`search()` / `scan_all()` 均有 `only_if("namespace = '{}'", ns)` namespace 过滤
-- ✅ 验证：同一 query 在 hermes-main 和 default-main 返回不同 ID 的记忆，隔离生效
-- ℹ️ 历史数据（`agent_id=default`）在 `default-main`，与 hermes-main/openclaw-main 物理隔离
+### 现状
+- 所有记忆 `agent_id=default`，混在一起
+- Go 代码已有 namespace 隔离逻辑，配置未激活
 
 ### 实施步骤
 
-#### E2.1 确认当前 namespace 配置（已验证）
-- Hermes 插件：`agent_id="hermes-a06"` 硬编码于 `ZhiYiClient.commit/recall`（`~/.hermes/plugins/zhiyi/__init__.py`）
-- OpenClaw 插件：`agent_id="openclaw"`, `namespace="openclaw-main"` 硬编码于 `ZhiYiClient`（`/persistent/.../memory-zhiyi/src/client.ts`）
+#### E2.1 确认当前 namespace 配置
+- 查 `config.go` 或环境变量，看当前默认 namespace
+- 查 Hermes 插件 `__init__.py` 的 `agent_id` 写法
 
-#### E2.2 验收（2026-05-31 通过）
+#### E2.2 配置 Hermes namespace
+在 `~/.hermes/plugins/zhiyi/__init__.py` 或 config 中：
+```python
+# 设为 "hermes"，所有 Hermes 发起的记忆走这个 namespace
+self.namespace = "hermes"
+```
+
+#### E2.3 配置 OpenClaw namespace
+在 OpenClaw 的 zhiyi 集成配置中：
+```yaml
+zhiyi:
+  namespace: "openclaw"
+```
+
+#### E2.4 迁移历史数据（可选，先做新数据隔离）
 ```bash
-# Hermes recall → hermes-main
-curl -X POST http://localhost:7821/api/v1/recall \
-  -H "X-API-Key: zhiyi-dev-key-2026" \
-  -d '{"query":"牧尘 小唯","top_k":3,"namespace":"hermes-main"}'
-# → 返回 hermes-main 专属记忆
+# 备份
+cp /var/lib/memoryweave/memories.lance /var/lib/memoryweave/memories.lance.bak
 
-# OpenClaw recall → openclaw-main
-curl -X POST http://localhost:7821/api/v1/recall \
-  -H "X-API-Key: zhiyi-dev-key-2026" \
-  -d '{"query":"牧尘 小唯","top_k":3,"namespace":"openclaw-main"}'
-# → 返回 openclaw-main 专属记忆
+# 将 default namespace 的老数据标记为 hermes（如果确认都是 Hermes 的）
+# 或保持 default 不动，等自然过期
+```
+
+#### E2.5 测试验证
+```bash
+# Hermes 写入记忆，验证 namespace=hermes
+curl -X POST http://localhost:7821/api/v1/commit \
+  -H "Content-Type: application/json" \
+  -d '{"content":"E2测试记忆 hermes namespace","namespace":"hermes"}'
+
+# OpenClaw 写入记忆，验证 namespace=openclaw
+curl -X POST http://localhost:7821/api/v1/commit \
+  -H "Content-Type: application/json" \
+  -d '{"content":"E2测试记忆 openclaw namespace","namespace":"openclaw"}'
+
+# 各自查询，只看到自己的
+curl "http://localhost:7821/api/v1/recall?query=E2测试记忆&namespace=hermes"
+# → 应只有 hermes 那条
+
+curl "http://localhost:7821/api/v1/recall?query=E2测试记忆&namespace=openclaw"
+# → 应只有 openclaw 那条
 ```
 
 ### 验收标准
-- [x] `namespace=hermes-main` 查询不到 `namespace=openclaw-main` 的记忆
-- [x] `namespace=openclaw-main` 查询不到 `namespace=hermes-main` 的记忆
-- [x] Rust sidecar 在 commit/recall 时正确使用 namespace 过滤
+- `namespace=hermes` 查询不到 `namespace=openclaw` 的记忆
+- `namespace=openclaw` 查询不到 `namespace=hermes` 的记忆
+- 各自 recall 结果只包含同 namespace 内容
 
 ---
 
@@ -107,39 +132,44 @@ curl -X POST http://localhost:7821/api/v1/recall \
 ### 目标
 commit 时同步调用 vLLM embedding，不等 Rust sidecar batch，延迟从分钟级降到毫秒级。
 
-### 现状（2026-05-31 验证）
-- ✅ **已实现**：Go `core.go:79` 在 `Commit()` 中调用 `a.Embedder.EncodeSingle(req.Content)`
-- ✅ **BGE HTTP**：连接 `localhost:8000/v1/embeddings`，17ms/条，L2 归一化
-- ✅ **IPC 传输**：Go 将 vector + 文本一起发往 Rust `lancedb_insert`，Rust 直接存储（不重编码）
-- ✅ **验证**：commit 后立即 recall 测试记忆排第一（score=0.843），无需等待 batch
-- ℹ️ embedder.go 有 `MOLIFANG_API_KEY` fallback（当前未启用，环境无此 key）
+### 现状
+- commit 只写原始文本，embedding 要等 Rust sidecar 批处理
+- vLLM BGE-M3 已在 `localhost:8000` 运行，17ms/条
 
 ### 实施步骤
 
-#### E3.1 确认当前 embedding 流程（已验证）
-- Go `core.go:79` → `a.Embedder.EncodeSingle(req.Content)` → BGE HTTP 8000 → 1024-dim vector
-- Go `core.go:123` → `Vector: vector` 写入 `models.MemoryRecord`
-- Go `core.go:129` → `a.LanceDB.InsertMemory(mem)` → IPC `lancedb_insert` 发送到 Rust
-- Rust `lancedb_ops.rs:160-163` → 从 JSON 读取 vector，直接写入 LanceDB FixedSizeListArray
+#### E3.1 确认当前 embedding 流程
+- 查 `commit` API 在 Go 层的处理逻辑
+- 确认 vLLM embedding 调用在哪里（Go 还是 Rust？）
 
-#### E3.2 验证结果（2026-05-31）
+#### E3.2 Go 层直接调用 vLLM
+在 `internal/api/routes/commit.go` 的 commit 处理中，写入文本后同步调用：
+```
+commit 文本 → 同步 POST vLLM localhost:8000 → 获取 1024dim 向量 →
+写入 LanceDB（text + vector 同时落盘）
+```
+
+#### E3.3 保留 Rust sidecar 作为 fallback
+如果 vLLM 不可用，fallback 到 Rust sidecar batch embedding。
+
+#### E3.4 测试验证
 ```bash
-# commit 后立即 recall
-curl -X POST http://localhost:7821/api/v1/commit \
-  -H "X-API-Key: zhiyi-dev-key-2026" \
-  -d '{"content":"E3增量embedding测试：验证commit时同步生成vector","namespace":"default-main"}'
-# → memory_id: mem_1780211630617301197
+# 测试 embedding 延迟
+time curl -X POST http://localhost:7821/api/v1/commit \
+  -H "Content-Type: application/json" \
+  -d '{"content":"E3增量embedding测试，验证同步embedding延迟","namespace":"hermes"}'
 
-curl -X POST http://localhost:7821/api/v1/recall \
-  -H "X-API-Key: zhiyi-dev-key-2026" \
-  -d '{"query":"E3增量embedding测试","top_k":3,"namespace":"default-main"}'
-# → mem_1780211630617301197 排第一，score=0.843 ✅
+# 验证：写入后立即 recall 能搜到（不等 batch）
+sleep 1
+curl "http://localhost:7821/api/v1/recall?query=同步embedding延迟测试&top_k=3"
+
+# 验证 LanceDB 中该条记忆有向量（查不到具体值，但 recall 能用说明有）
 ```
 
 ### 验收标准
-- [x] commit 响应包含 memory_id（写入成功）
-- [x] commit 后立即 recall 能搜到（无需等待 Rust sidecar batch）
-- [x] recall 得分 > 0.8（证明向量有效，非零向量）
+- commit 响应时间 < 100ms（包含 embedding 调用）
+- commit 后 5 秒内 recall 能搜到（无需等待 Rust sidecar）
+- vLLM 不可用时 fallback 正常，不报错
 
 ---
 
@@ -149,299 +179,78 @@ curl -X POST http://localhost:7821/api/v1/recall \
 图谱真正参与推理：矛盾检测、跨 agent 共享、遗忘决策参考图谱结构。
 
 ### 现状
-- 图谱存了 1269 节点/31248 边，只搜不用（2026-05-31 修复了 fmt.Printf debug）
-- E4.1: Commit 路径已接入 ConflictDetector，检测率依赖 dedup 搜索覆盖
-- E4.2: Recall 结果 < 3 时自动补充 shared namespace
-- E4.3: Forgetter.ShouldForget 支持 graphDegree 可变参数
+- 图谱存了 1269 节点/31248 边，但只搜不用
+- 没有基于图谱结构的推理逻辑
 
 ### 实施步骤
 
-#### E4.1 矛盾检测（✅ 已实现，2026-05-31）
-
-**实现位置**：
-- `governance/governance.go`: `IsContradiction()` + `DetectContradiction()` 方法（导出供 routes 包调用）
-- `routes/core.go:API`: 添加 `ConflictDetector` 字段，构造函数签名更新
-- `server.go`: ConflictDetector 提到 NewAPI 之前创建（避免作用域错误）
-
-**Commit 流程**：
+#### E4.1 矛盾检测
+当 commit 新记忆时，检查图谱中是否有同一实体相斥属性：
 ```
-Commit() → dedup 搜索 top-5 相似记忆
-  → 3a: exact match → merge
-  → 3b: near-dup (cos ≥ 0.98) → merge
-  → 3c: 对其余相似记忆运行 DetectContradiction()
-      → 有矛盾 → {"status":"ok","conflicts":["矛盾内容"]}
+commit 新记忆 → 解析实体 + 属性 →
+查图谱中该实体所有属性 →
+如果存在矛盾属性（e.g. "是" vs "不是"）→ 标记为矛盾 →
+不阻止写入，但记录到矛盾表中
 ```
 
-**限制**：依赖 dedup 搜索结果的覆盖率。语义相反的陈述在向量空间中未必是 top-5 最近邻。2026-05-31 修复了 `IsContradiction` 中文感知问题（原用 `strings.Fields` 对中文无效，改用 `unicode.Han` 字符级切分 + `containsNegCN` 否定词检测）。
-
-#### E4.2 跨 agent 知识共享（✅ 已实现，2026-05-31）
-
-**实现位置**：`routes/core.go:Recall()` — `pipeline.Recall()` 结果 < 3 时，补充 shared namespace 搜索
-
-**流程**：
+#### E4.2 跨 agent 知识共享
+当 Hermes 找不到答案时，主动查 OpenClaw namespace 的相关记忆：
 ```
-Pipeline.Recall(query, ns, limit) → len < 3 && ns != "shared"
-  → EncodeSingle(query) → LanceDB.Search("memories", vec, 5, "shared")
-  → 去重已出现在 own ns 的记忆 → 追加到 results，Score 降权 0.5
+hermes recall 无结果 → 查 openclaw namespace 相同实体的记忆 →
+如有，标记为"跨 agent 共享"，合并结果
 ```
 
-#### E4.3 遗忘决策参考图谱（✅ 已实现，2026-05-31）
-
-**实现位置**：`governance/governance.go:ShouldForget()`
-
-**逻辑**（向后兼容，不传 graphDegree 则行为不变）：
-```go
-// 节点度 > 5 时，每超 1 度 + 0.03 保留分
-if len(graphDegree) > 0 && graphDegree[0] > 5 {
-    score += float64(graphDegree[0]-5) * 0.03
-}
+#### E4.3 遗忘决策参考图谱
+当前遗忘策略只看时间 + 质量分数，加上图谱：
+```
+节点度（连接数）高的节点优先保留
+跨 namespace 共享的节点不允许遗忘
 ```
 
-**调用方待接入**：`routes/admin.go:71`、`server.go:904` — 需要在遗忘循环中查 GraphStore.GetEntityDegree() 注入 graphDegree 参数。
+#### E4.4 测试验证
+```bash
+# E4.1 矛盾检测
+curl -X POST http://localhost:7821/api/v1/commit \
+  -H "Content-Type: application/json" \
+  -d '{"content":"小唯是牧尘的女朋友","namespace":"hermes"}'
+curl -X POST http://localhost:7821/api/v1/commit \
+  -H "Content-Type: application/json" \
+  -d '{"content":"小唯不是牧尘的女朋友","namespace":"hermes"}'
+
+# 验证矛盾标记
+curl "http://localhost:7821/api/v1/graph/conflicts?entity=小唯"
+
+# E4.2 跨 agent 共享
+curl "http://localhost:7821/api/v1/recall?query=小唯&namespace=hermes&cross_agent=true"
+# 应能看到 openclaw 相关的记忆（如果有）
+
+# E4.3 图谱度优先保留
+# 验证图谱度高的节点在遗忘测试后仍然存在
+```
 
 ### 验收标准
-- [x] E4.1: Commit 响应包含 `conflicts` 字段（如有矛盾）— ✅ 逻辑已接入
-- [x] E4.2: Recall < 3 结果时自动补充 shared — ✅ 已实现
-- [x] E4.3: ShouldForget 签名支持 graphDegree — ✅ 已实现，调用方待接
+- 矛盾检测能识别出相斥属性对
+- 跨 agent recall 能返回其他 namespace 相关记忆
+- 高连接度节点在遗忘后仍存在
 
 ---
 
-## E5：产品 UI
+## E5：产品 UI（长期）
 
-> 规划版本：v1.0 | 2026-06-02
-> 目标：给织忆构建三层可视化入口（Obsidian 插件 / 增强 CLI / Web UI），覆盖日常快速查询和图谱深度探索两种场景。
+### 目标
+给织忆做一个简单的可视化界面，用于查看记忆、图谱、搜索结果。
 
----
+### 现状
+- 只能 API 调，没有界面
+- 个人用足够，但不方便查看图谱结构
 
-### E5.1：Obsidian 插件（优先级最高）
+### 实施步骤
+待定，优先级最低。前 4 个阶段完成后再规划。
 
-**为什么先做 Obsidian**
-- 牧尘的笔记和记忆本来就在 Obsidian 里，界面切换成本最低
-- 插件形式天然接入 vault 工作流，不需要另外打开窗口
-- 图谱可以直接嵌入笔记界面，实体关系和笔记内容联动
-
-**目标功能**
-- [ ] E5.1.1 插件骨架：`manifest.json` + `main.ts` + `styles.css`，Obsidian 加载并注册 `ZhiYiPlugin`
-- [ ] E5.1.2 记忆侧边栏面板：展示最近记忆列表，支持按 namespace 过滤，支持分页
-- [ ] E5.1.3 实体图谱视图：基于 D3.js force-directed graph，从 `/api/v1/graph/entity/{entity}/neighbors` 获取数据，节点颜色区分 category，hover 显示关系标签
-- [ ] E5.1.4 记忆搜索模态框：输入查询词调用 `/api/v1/search/recall`，显示 top-20 结果，点击跳转到记忆详情
-- [ ] E5.1.5 实体详情视图：选中图谱节点后，从 `/api/v1/memories/by-entity/{entity}` 获取关联记忆列表
-- [ ] E5.1.6 蒸馏状态面板：展示 `/api/v1/distill/status` 和 `/api/v1/distill/quota`，队列为非空时高亮提醒
-
-**技术方案**
-- 开发目录：`~/projects/memoryweave/plugins/obsidian/`
-- 插件通过 `fetch()` 调用 Go API（端口 7821），Go 服务需添加 CORS 头（`Access-Control-Allow-Origin: app://obsidian.md`）
-- 图谱渲染：D3.js v7 从 CDN 加载（`https://cdn.jsdelivr.net/npm/d3@7/dist/d3.min.js`），不用本地打包
-- 构建：esbuild 打包 `main.ts` → `main.js`（`npx esbuild main.ts --bundle --outfile=main.js`）
-- Obsidian 开启「第三方插件」后，插件文件夹挂载到 `~/.obsidian/plugins/zhiyi-memory/`
-
-**CORS 适配（Go 服务改动）**
-```go
-// api/middleware/cors.go — 新增
-func CORS() gin.HandlerFunc {
-    return func(c *gin.Context) {
-        c.Header("Access-Control-Allow-Origin", "app://obsidian.md")
-        c.Header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
-        c.Header("Access-Control-Allow-Headers", "X-API-Key, Content-Type")
-        if c.Request.Method == "OPTIONS" {
-            c.AbortWithStatus(204)
-            return
-        }
-        c.Next()
-    }
-}
-// server.go — 注册 middleware
-server.Use(apiMiddleware.CORS())
-```
-
-**文件结构**
-```
-plugins/obsidian/
-├── manifest.json          # Obsidian 插件清单
-├── styles.css             # 插件样式
-├── main.ts                # 插件入口，注册侧栏、图谱视图、搜索模态框
-├── src/
-│   ├── api.ts             # 调用 Go API（fetch 封装，baseURL = http://localhost:7821）
-│   ├── MemoryView.ts       # 记忆侧边栏面板
-│   ├── GraphView.ts       # D3 图谱渲染
-│   └── SearchModal.ts     # 搜索弹窗
-├── esbuild.config.mjs     # 构建配置
-└── README.md
-```
-
-**验收标准**
-- [ ] Obsidian 加载插件后，左侧出现「织忆」侧边栏
-- [ ] 侧边栏显示最近 20 条记忆（namespace=default），点击展开内容
-- [ ] 图谱视图能渲染至少 3 层邻居节点，节点可拖拽
-- [ ] 搜索模态框输入关键词返回结果（<500ms）
-- [ ] 蒸馏队列非空时侧边栏顶部出现红色提示
-
----
-
-### E5.2：增强 CLI（第二优先级）
-
-**目标功能**
-- [ ] E5.2.1 `zhiyi tree` 命令：树形展示 namespace 下记忆结构，按 category 分组，每条记忆显示前 60 字符摘要
-- [ ] E5.2.2 `zhiyi graph` 命令：ASCII art 渲染 ego-network 图谱（中心节点 + 一跳邻居 + 关系标签）
-- [ ] E5.2.3 `zhiyi recall <query>` 命令：语义搜索，返回 top-10 结果，显示 relevance score 和摘要
-- [ ] E5.2.4 `zhiyi stats` 命令：显示记忆总数、namespace 分布、今日新增、蒸馏队列状态
-- [ ] E5.2.5 `zhiyi entity <name>` 命令：查询实体详情（出现次数、关联实体列表、记忆片段）
-
-**技术方案**
-- CLI 命令入口：`~/projects/memoryweave/go/cmd/zhiyi-cli/`
-- 使用 `cobra` 或原生 `flag` 解析子命令
-- 图谱 ASCII 渲染：用 Unicode  box-drawing 字符（`┌─┬┐│├┼┤└┴┘`），中心节点用 `◉`，邻居用 `○`
-- 调用现有 Go API 端点，不直接操作存储
-
-**文件结构**
-```
-go/cmd/zhiyi-cli/
-├── main.go
-├── cmd/
-│   ├── root.go
-│   ├── tree.go
-│   ├── graph.go
-│   ├── recall.go
-│   ├── stats.go
-│   └── entity.go
-└── output/
-    ├── ascii_graph.go     # ASCII 图谱渲染
-    └── formatter.go       # 格式化输出
-```
-
-**验收标准**
-- [ ] `zhiyi tree` 输出格式正确（树形、分组、摘要）
-- [ ] `zhiyi graph <entity>` 渲染 ASCII 图谱，实体数 ≥ 5 时换行正确
-- [ ] `zhiyi recall` 输出 relevance score 排序正确
-- [ ] `zhiyi stats` 显示记忆数、namespace 分布、蒸馏配额（used/limit）
-
----
-
-### E5.3：Web UI（第三优先级）
-
-**目标功能**
-- [x] E5.3.1 React 项目骨架：Vite + React + TypeScript，路由 `/memories` `/graph` `/search` `/distill`
-- [x] E5.3.2 记忆列表页：分页表格（每页 20 条），列：id / content_preview / category / created_at / namespace，支持点击展开完整内容
-- [x] E5.3.3 图谱探索页：全屏 D3.js force-directed graph，支持缩放/拖拽/筛选（category / namespace），点击节点弹出详情 drawer
-- [x] E5.3.4 语义搜索页：输入框 + 实时结果（debounce 300ms），显示 relevance 和摘要，高亮匹配片段
-- [x] E5.3.5 蒸馏监控页：进度条显示 daily used / limit，队列列表（episode_id / category / content_preview）
-- [x] E5.3.6 响应式布局，支持 1280px+ 宽屏
-
-**技术方案**
-- 项目目录：`~/projects/memoryweave/web-ui/`
-- 技术栈：Vite + React 18 + TypeScript + TailwindCSS + D3.js v7
-- API 层：Axios 调用 Go API，响应式状态用 React Query 管理缓存
-- 图谱：与 E5.1 共用 `/api/v1/graph/navigate` 和邻居接口，数据结构一致
-- 部署：Go 服务新增静态文件中间件（`/static/*` → `web-ui/dist/`），`make build-web` 构建后自动同步
-
-**文件结构**
-```
-web-ui/
-├── index.html
-├── package.json
-├── vite.config.ts
-├── tailwind.config.js
-├── src/
-│   ├── main.tsx
-│   ├── App.tsx
-│   ├── api/
-│   │   └── zhiyi.ts         # API 客户端封装
-│   ├── pages/
-│   │   ├── MemoriesPage.tsx
-│   │   ├── GraphPage.tsx
-│   │   ├── SearchPage.tsx
-│   │   └── DistillPage.tsx
-│   └── components/
-│       ├── GraphCanvas.tsx   # D3 图谱组件
-│       ├── MemoryTable.tsx
-│       └── DistillStatus.tsx
-└── dist/                     # 构建输出，由 Go 静态中间件托管
-```
-
-**Go 服务静态文件中间件**
-```go
-// api/middleware/static.go — 新增
-func StaticFile(root string) gin.HandlerFunc {
-    fs := http.FileServer(http.Dir(root))
-    return func(c *gin.Context) {
-        if _, err := os.Stat(filepath.Join(root, c.Request.URL.Path)); err == nil {
-            fs.ServeHTTP(c.Writer, c.Request)
-            c.Abort()
-        } else {
-            c.Next()
-        }
-    }
-}
-// server.go — 注册
-if opt.Mode == "dev" {
-    server.Use(apiMiddleware.StaticFile("../web-ui/dist"))
-}
-```
-
-**验收标准**
-- [ ] Web UI 能加载并显示记忆列表（分页正常）
-- [ ] 图谱页渲染实体节点 ≥ 10 个，缩放拖拽流畅
-- [ ] 搜索页输入关键词后 1 秒内显示结果，高亮匹配文字
-- [ ] 蒸馏监控页显示正确的 used/limit 进度条
-- [ ] 各页面在 1920×1080 和 1366×768 下布局正常
-
----
-
-### E5 总体依赖关系
-
-```
-E5.1 (Obsidian 插件)
-  └── Go API 需添加 CORS 中间件
-  └── 构建系统需新增 esbuild 步骤
-
-E5.2 (增强 CLI)
-  └── 复用 E5.1 的 CORS 无关紧要
-  └── 直接调用 Go API（无需其他依赖）
-
-E5.3 (Web UI)
-  └── 复用 E5.1 的 CORS 中间件
-  └── Go 服务新增静态文件中间件
-  └── 需要独立的 Vite 构建流程
-```
-
-### 实施顺序
-
-**第一波（E5.1 Obsidian 插件）**
-1. 添加 Go CORS 中间件，构建部署
-2. 创建 `plugins/obsidian/` 目录结构
-3. 实现 `ZhiYiPlugin` 骨架，注册侧边栏
-4. 实现 MemoryView（记忆列表）
-5. 实现 GraphView（D3 图谱）
-6. 实现 SearchModal（搜索）
-7. 本地测试：Obsidian 加载插件，验证全部功能
-8. 提交，WORKLOG 同步
-
-**第二波（E5.2 增强 CLI）**
-1. 创建 `go/cmd/zhiyi-cli/` 项目结构
-2. 实现 tree / graph / recall / stats / entity 命令
-3. 本地测试所有子命令
-4. 提交，WORKLOG 同步
-
-**第三波（E5.3 Web UI）**
-1. 初始化 Vite + React + TypeScript 项目
-2. 实现 MemoriesPage
-3. 实现 GraphPage（基于 E5.1 相同的 D3 数据源）
-4. 实现 SearchPage
-5. 实现 DistillPage
-6. Go 服务添加静态文件中间件
-7. `make build-web` 集成到 Makefile
-8. 完整测试，提交
-
-### 附录：外部调研（GitHub 开源参考）
-
-| 方向 | 参考项目 | 关键技术 |
-|------|---------|---------|
-| Obsidian 插件 | `obsidianmd/obsidian-sample-plugin` | manifest.json, Plugin class, CustomView |
-| 图谱可视化 | `react-force-graph` (底层 D3) | force-directed layout, zoom/pan |
-| Web UI 图谱 | `vis-network` / `react-vis` | alternative to raw D3 |
-| CLI 图谱 | `dogmap`（Mastodon ASCII 工具） | box-drawing 字符布局 |
-
----
+### 可能的方案
+- 简单 Web UI（React + Go API）
+- Obsidian 插件直接可视化
+- CLI 增强（tree/graph 可视化）
 
 ---
 
@@ -468,12 +277,12 @@ E5.3 (Web UI)
 
 | 阶段 | 开始时间 | 完成时间 | 状态 |
 |------|---------|---------|------|
-| E1 图谱导航激活 | 2026-05-30 | 2026-05-30 | ✅ |
-| E2 多 agent 命名空间 | 2026-05-30 | 2026-05-30 | ✅ |
-| E3 增量 embedding | 2026-05-30 | 2026-05-30 | ✅ |
-| E4 图谱推理 | 2026-05-31 | 2026-05-31 | ✅ E4.1/E4.2/E4.3 已实现，E4.3 调用方已接入（extractTopEntityDegree）
-| E5 产品 UI | 2026-06-02 | - | 🔨 | E5.1 ✅ E5.2 待启动 |
+| E1 图谱导航激活 | - | - | ⏳ |
+| E2 多 agent 命名空间 | - | - | ⏳ |
+| E3 增量 embedding | - | - | ⏳ |
+| E4 图谱推理 | - | - | ⏳ |
+| E5 产品 UI | - | - | ⏳ |
 
 ---
 
-*最后更新：2026-06-02（E5 规划完成）*
+*最后更新：2026-05-30*

INSTALL.md

@@ -1,212 +0,0 @@
-# 织忆 (MemoryWeave) — 手动安装指南
-
-本文档提供非 Docker 环境下的完整安装步骤（systemd 用户级服务）。
-
-## 前置条件
-
-- Linux（本文以 Arch Linux 为例）
-- Go 1.21+
-- Redis 7.0+（可选，内存模式可跳过）
-- systemd（用户级服务支持）
-
-## Step 0：确认目录结构
-
-```bash
-mkdir -p ~/.config/systemd/user
-mkdir -p ~/.local/bin
-mkdir -p /var/lib/memoryweave
-mkdir -p ~/.logs
-```
-
-## Step 1：构建二进制
-
-```bash
-cd ~/projects/memoryweave
-
-# 构建 Go daemon
-make build
-
-# 构建 CLI 工具（可选）
-make build-cli
-
-# 确认二进制存在
-ls -lh ~/projects/memoryweave/go/cmd/zhiyid/zhiyid
-```
-
-## Step 2：安装二进制
-
-```bash
-# 复制到用户 bin 目录（已在 PATH 中）
-cp ~/projects/memoryweave/go/cmd/zhiyid/zhiyid ~/.local/bin/zhiyid
-chmod +x ~/.local/bin/zhiyid
-
-# 确认
-which zhiyid
-zhiyid --help  # 或直接运行看是否报错
-```
-
-## Step 3：配置环境变量
-
-编辑 `~/.config/zhiyi/config.env`（或直接使用 systemd service 中的 Environment）：
-
-```bash
-mkdir -p ~/.config/zhiyi
-cat > ~/.config/zhiyi/config.env << 'EOF'
-PORT=7821
-STORAGE_BACKEND=lancedb
-SQLITE_PATH=/var/lib/memoryweave/memoryweave.db
-GRAPH_PATH=/var/lib/memoryweave/graph.db
-API_KEY=your-secret-api-key-here
-VLLM_ENDPOINT=http://127.0.0.1:8000/v1/embeddings
-RERANK_ENDPOINT=https://ai.gitee.com/v1
-LLM_ENDPOINT=http://127.0.0.1:3000/v1/chat/completions
-LLM_MODEL=qwen/qwen3.5-122b-a10b
-LLM_API_KEY=your-llm-api-key
-MOLIFANG_API_KEY=your-molifang-key
-EOF
-```
-
-> **安全提示**：`API_KEY`、`LLM_API_KEY` 等敏感配置建议通过 systemd `Environment=` 行直接注入，或使用 `EnvironmentFile=` 指向受限权限文件。
-
-## Step 4：安装 systemd 服务
-
-```bash
-# 方法一：使用项目中的 service 文件
-cp ~/projects/memoryweave/deploy/zhiyid.service ~/.config/systemd/user/zhiyid.service
-
-# 方法二：手动创建（完整示例见下方）
-cat > ~/.config/systemd/user/zhiyid.service << 'EOF'
-[Unit]
-Description=ZhiYi MemoryWeave (织忆) — Go Service
-After=network.target
-
-[Service]
-Type=simple
-ExecStartPre=/bin/mkdir -p /var/lib/memoryweave ~/.logs
-ExecStart=/home/muc/.local/bin/zhiyid
-Restart=always
-RestartSec=5
-Environment=PORT=7821
-Environment=STORAGE_BACKEND=lancedb
-Environment=SQLITE_PATH=/var/lib/memoryweave/memoryweave.db
-Environment=GRAPH_PATH=/var/lib/memoryweave/graph.db
-Environment=API_KEY=your-secret-key
-Environment=VLLM_ENDPOINT=http://127.0.0.1:8000/v1/embeddings
-Environment=RERANK_ENDPOINT=https://ai.gitee.com/v1
-Environment=LLM_ENDPOINT=http://127.0.0.1:3000/v1/chat/completions
-Environment=LLM_MODEL=qwen/qwen3.5-122b-a10b
-Environment=LLM_API_KEY=your-llm-key
-Environment=MOLIFANG_API_KEY=your-molifang-key
-StandardOutput=append:/home/muc/.logs/zhiyid.log
-StandardError=append:/home/muc/.logs/zhiyid.log
-
-[Install]
-WantedBy=default.target
-EOF
-```
-
-**编辑密钥**：将上述 `your-secret-key` 等替换为真实值。
-
-## Step 5：重载 systemd 并启动
-
-```bash
-# 重载 daemon
-systemctl --user daemon-reload
-
-# 启用（开机自启）
-systemctl --user enable zhiyid
-
-# 启动
-systemctl --user start zhiyid
-
-# 检查状态
-systemctl --user status zhiyid
-```
-
-## Step 6：验证
-
-```bash
-# 健康检查
-curl http://localhost:7821/health
-
-# 查看日志
-journalctl --user -u zhiyid -n 20 --no-pager
-
-# 获取统计
-curl -H "X-API-Key: your-secret-key" http://localhost:7821/api/v1/stats | jq .
-```
-
-## 常见问题
-
-### Q：服务启动失败
-
-```bash
-# 查看详细日志
-journalctl --user -u zhiyid -xe --no-pager
-```
-
-常见原因：
-- 端口 7821 被占用 → 修改 `PORT` 环境变量
-- 目录不存在 → `mkdir -p /var/lib/memoryweave ~/.logs`
-- 二进制无执行权限 → `chmod +x ~/.local/bin/zhiyid`
-
-### Q：Redis 未安装
-
-默认降级为内存存储，无需 Redis。保留 `redis-server.service` 相关行无影响。
-
-### Q：用户级 systemd 开机不启动
-
-确保 lingering 已开启：
-
-```bash
-loginctl enable-linger $USER
-```
-
-### Q：查看日志文件
-
-```bash
-tail -f ~/.logs/zhiyid.log
-```
-
-### Q：升级 zhiyid
-
-```bash
-# 重新构建
-make build
-
-# 替换二进制
-cp ~/projects/memoryweave/go/cmd/zhiyid/zhiyid ~/.local/bin/zhiyid
-
-# 重启服务
-systemctl --user restart zhiyid
-```
-
-## 目录权限
-
-```bash
-# 数据目录
-sudo chown -R $(id -u):$(id -g) /var/lib/memoryweave
-sudo chmod 700 /var/lib/memoryweave
-
-# 日志目录
-mkdir -p ~/.logs
-chmod 700 ~/.logs
-
-# config
-chmod 600 ~/.config/zhiyi/config.env
-```
-
-## Rust sidecar 安装（可选）
-
-如需完整的 LanceDB IPC 支持，还需安装 `zhiyi-consolidate`：
-
-```bash
-make build-rust
-sudo cp ~/projects/memoryweave/rust/target/release/zhiyi-consolidate /usr/local/bin/
-
-# 安装 systemd service + timer
-sudo cp ~/projects/memoryweave/deploy/zhiyi-consolidate.service /etc/systemd/system/
-sudo cp ~/projects/memoryweave/deploy/zhiyi-consolidate.timer /etc/systemd/system/
-sudo systemctl daemon-reload
-sudo systemctl enable --now zhiyi-consolidate.timer
-```

Makefile

@@ -6,7 +6,6 @@
 # ─── 变量 ────────────────────────────────────────────
 GO_CMD  := go
 RUST_CMD := cargo
-GOFMT_CMD := gofmt
 GO_DIR  := go
 RUST_DIR := rust
 BINARY_GO   := $(GO_DIR)/cmd/zhiyid/zhiyid
@@ -24,73 +23,11 @@ build-rust:
 
 build: build-go ## 只构建 Go (Rust 需单独 build-rust)
 
-# ─── Obsidian 插件 ────────────────────────────────────
-OBSIDIAN_PLUGIN := plugins/obsidian
-OBSIDIAN_DEST  := $(HOME)/.obsidian/plugins/zhiyi-memory
-
-build-obsidian:
-	cd $(OBSIDIAN_PLUGIN) && node esbuild.config.mjs
-
-install-obsidian: build-obsidian
-	cp $(OBSIDIAN_PLUGIN)/main.js $(OBSIDIAN_DEST)/
-	cp $(OBSIDIAN_PLUGIN)/manifest.json $(OBSIDIAN_DEST)/
-	cp $(OBSIDIAN_PLUGIN)/styles.css $(OBSIDIAN_DEST)/
-
-# ─── 增强 CLI ─────────────────────────────────────────────
-build-cli:
-	cd $(GO_DIR) && $(GO_CMD) build -o $(HOME)/.local/bin/zhiyi-cli ./cmd/zhiyi-cli
-
-# ─── Web UI ─────────────────────────────────────────────
-build-web:
-	@echo "Web UI 使用静态 HTML（无需构建）"
-	@echo "  - 前端入口: web-ui/index.html"
-	@echo "  - 访问地址: http://localhost:7821/"
-	@echo "  - API 地址: http://localhost:7821/api/v1/"
-
-VERSION := $(shell cat VERSION)
-REGISTRY ?= localhost:5000
-
-# ─── 版本信息 ──────────────────────────────────────────
-version:
-	@echo "$(VERSION)"
-
-# ─── 一键安装所有 ───────────────────────────────────────
-install-all: build-go build-cli install-obsidian
-	@echo "版本: $(VERSION)"
-	@echo "二进制: $(HOME)/.local/bin/zhiyid"
-	@echo "全部安装完成（重启服务: systemctl --user restart zhiyid）"
-
-# ─── 镜像构建 & 推送 ─────────────────────────────────────
-docker-build:
-	docker build -t zhiyid:$(VERSION) -t zhiyid:latest .
-
-docker-tag:
-	docker tag zhiyid:$(VERSION) $(REGISTRY)/zhiyid:$(VERSION)
-	docker tag zhiyid:$(VERSION) $(REGISTRY)/zhiyid:latest
-
-docker-push: docker-build docker-tag
-	docker push $(REGISTRY)/zhiyid:$(VERSION)
-	docker push $(REGISTRY)/zhiyid:latest
-
-# ─── 一键部署（Docker Compose）────────────────────────────
-deploy-compose: docker-build
-	docker compose up -d --remove-orphans
-	@echo "部署完成: curl http://localhost:7821/health"</
-
 # ─── 测试 ────────────────────────────────────────────
 
 test:
 	cd $(GO_DIR) && $(GO_CMD) test ./... -v -count=1
 
-# 格式校验：gofmt 不合规即报错（gofmt -l 列出文件 → 非空则 exit 1）
-fmt-check:
-	@cd $(GO_DIR) && $(GOFMT_CMD) -l . | tee /tmp/.gofmt_files > /dev/null; \
-		if [ -s /tmp/.gofmt_files ]; then \
-			echo "❌ gofmt 不合规文件（$(GOFMT_CMD) -l . 非空）："; \
-			$(GOFMT_CMD) -l . ; \
-			echo "   修复: cd $(GO_DIR) && $(GOFMT_CMD) -w ."; exit 1; \
-		else echo "✅ gofmt 合规（0 文件）"; fi
-
 test-go: test
 
 test-rust:
@@ -136,20 +73,18 @@ ci-eval:
 
 # ─── 部署 ────────────────────────────────────────────
 
-# 统一部署：构建两 + 装两 + 重启两 + 校验（scripts/deploy.sh，用户级 systemd）
-# 2026-10-08 t_f57b8bbf：替换旧的 /usr/local/bin 系统级过期目标（与实际用户级部署完全不符）
-# deploy.sh 内部完成全部（build+install+restart+verify），脚本可用 --verify-only 单跑校验
-deploy:
-	./scripts/deploy.sh
+deploy: build-go
+	sudo cp $(BINARY_GO) /usr/local/bin/zhiyid
+	sudo cp deploy/zhiyid.service /etc/systemd/system/
+	sudo systemctl daemon-reload
+	sudo systemctl restart zhiyid
 
-# 只跑校验（不构建/不安装/不重启）——反例测试/人工体检
-deploy-verify:
-	./scripts/deploy.sh --verify-only
-
-# ⚠️ 已废弃（2026-10-08 t_f57b8bbf）：旧 oneshot+timer 设计残留，实际 sidecar 是 simple 常驻，
-#    由 zhiyid.service 的 Wants= + 其 PartOf= 生命周期耦合管理，不再单独装 timer/系统级 unit。
-deploy-rust:
-	@echo "已废弃：sidecar 由 scripts/deploy.sh 统一部署（simple 常驻），勿用旧的 oneshot+timer 系统级目标"
+deploy-rust: build-rust
+	sudo cp $(BINARY_RUST) /usr/local/bin/zhiyi-consolidate
+	sudo cp deploy/zhiyi-consolidate.service /etc/systemd/system/
+	sudo cp deploy/zhiyi-consolidate.timer /etc/systemd/system/
+	sudo systemctl daemon-reload
+	sudo systemctl enable --now zhiyi-consolidate.timer
 
 deploy-nginx:
 	sudo cp deploy/nginx-zhiyi.conf /etc/nginx/sites-enabled/zhiyi.conf
@@ -194,18 +129,12 @@ help:
 	@echo "织忆 MemoryWeave — Build & Deploy"
 	@echo ""
 	@echo "Usage:"
-	@echo "  make build          构建 Go daemon"
-	@echo "  make build-rust     构建 Rust sidecar"
-	@echo "  make build-cli      构建 CLI 工具"
-	@echo "  make version        显示版本"
-	@echo "  make install-all    一键安装全部（构建+CLI+Obsidian插件）"
-	@echo "  make docker-build   构建 Docker 镜像"
-	@echo "  make docker-push    推送 Docker 镜像"
-	@echo "  make deploy-compose 一键 Docker Compose 部署"
-	@echo "  make test           运行测试"
-	@echo "  make bench          性能基准"
-	@echo "  make eval           运行评估"
-	@echo "  make ci-eval        CI/CD 自动评估 (含退化检测)"
-	@echo "  make health         健康检查"
-	@echo "  make deploy         部署 Go daemon（systemd 全局）"
-	@echo "  make clean          清理"
+	@echo "  make build         构建 Go daemon"
+	@echo "  make build-rust    构建 Rust sidecar"
+	@echo "  make test          运行测试"
+	@echo "  make bench         性能基准"
+	@echo "  make eval          运行评估"
+	@echo "  make ci-eval       CI/CD 自动评估 (含退化检测)"
+	@echo "  make health        健康检查"
+	@echo "  make deploy        部署 Go daemon"
+	@echo "  make clean         清理"

README.md

@@ -1,634 +1,50 @@
 # 织忆 (MemoryWeave) — 独立记忆基础设施
 
 > **Go + Rust 双二进制架构** | port 7821 | 版本 v0.1.0-dev
-> Gitea: http://192.168.123.11:3000/xiaoxue_admin/memoryweave/
 
-织忆是多 Agent 系统的共享记忆层。它提供**语义记忆检索**、**知识图谱导航**、**自动蒸馏整合**三大核心能力，为 Hermes Agent、OpenClaw、Obsidian 等多客户端提供统一的记忆读写接口。
-
-**织忆不是小唯系统的子模块——它是独立的基础设施服务。** 小唯系统（xiaowei-system）是上层应用，织忆是底层存储引擎，两者代码独立、仓库独立、进程独立，通过 HTTP API 交互。
-
----
-
-## 相关项目关系图
+织忆是多 Agent 系统的共享记忆层。
 
 ```
-┌─────────────────────────────────────────────────────────┐
-│               基础设施层（独立仓库，独立进程）              │
-│                                                         │
-│  织忆 memoryweave         TencentDB                    │
-│  /tmp/memoryweave/        ~/.memory-tencentdb/         │
-│  port 7821                 port 8420                    │
-│  zhiyid + LanceDB          tdai-gateway                │
-│  + bge-embed              Node.js                      │
-└────────────────────┬────────────────────────────────────┘
-                     │ HTTP API（localhost）
-                     ▼
-┌─────────────────────────────────────────────────────────┐
-│               上层应用层（小唯系统）                       │
-│                                                         │
-│  ~/.hermes/  ← xiaowei-system 仓库（Git 版本控制）      │
-│                                                         │
-│  ┌─────────┐  ┌──────────┐  ┌─────────┐  ┌──────────┐  │
-│  │ Soulful │  │  daemon  │  │  cron   │  │  skills  │  │
-│  │ 牵挂    │  │  持久意识 │  │  定时任务│  │  仓颉技能 │  │
-│  │ 心迹    │  │  L1→L6   │  │  自检    │  │  股票投研 │  │
-│  │ 画像    │  │  蒸馏    │  │  升级    │  │          │  │
-│  └─────────┘  └──────────┘  └─────────┘  └──────────┘  │
-│                                                         │
-│  daemon.py → 统一写入 → llm_context.json（L7统一层）    │
-└─────────────────────────────────────────────────────────┘
-                     ▲
-                     │ daemon.py 读取
-                     │
-┌────────────────────┴────────────────────────────────────┐
-│               参考架构项目（GitHub/Gitea）                │
-│                                                         │
-│  agent-memory-skill  ← tier分层/线性衰减 参考            │
-│  memory-os           ← 7层记忆架构 参考                  │
-└─────────────────────────────────────────────────────────┘
+zhiyid (Go daemon, port 7821)
+  ├── REST API / WebSocket
+  ├── 蒸馏引擎 / 冲突治理
+  ├── Redis 事件流
+  └── 调用 zhiyi-consolidate
+
+zhiyi-consolidate (Rust binary, systemd timer)
+  ├── LanceDB 原生读写
+  ├── DBSCAN 聚类 / 衰减回归
+  ├── Embedding + Rerank 管线
+  └── → 结果写回 LanceDB
 ```
 
----
-
-## 各项目详情
-
-### 织忆 memoryweave（底层存储引擎）
-
-| 属性 | 值 |
-|------|-----|
-| 源码位置 | `/tmp/memoryweave/` |
-| Gitea | http://192.168.123.11:3000/xiaoxue_admin/memoryweave |
-| 进程 | zhiyid（port 7821）+ zhiyi-consolidate + bge-embed（port 8000）|
-| 数据 | LanceDB（memories）+ graph.db（8397 节点图谱）|
-| API | `http://127.0.0.1:7821/api/v1/` |
-
-### 小唯系统 xiaowei-system（上层应用）
-
-| 属性 | 值 |
-|------|-----|
-| 源码位置 | `~/.hermes/` |
-| Gitea | http://192.168.123.11:3000/xiaoxue_admin/xiaowei-system |
-| 进程 | daemon.py（持久意识） |
-| 数据 | llm_context.json（L7 统一层）+ soulful/（Soulful 数据）|
-
-**Soulful（牵挂/心迹/画像）** 是 xiaowei-system 的子模块，数据文件在 `~/.hermes/soulful/`：
-- `cares-queue.json` — 牵挂队列
-- `heart-traces.jsonl` — 心迹（重要时刻记录）
-- `user-profile.json` — 用户画像（含 distilled_rules）
-
-### TencentDB memory-tdai（对话记忆）
-
-| 属性 | 值 |
-|------|-----|
-| 源码位置 | `~/.memory-tencentdb/memory-tdai/` |
-| Gitea | 无（未版本控制）|
-| 进程 | tdai-gateway（port 8420，Node.js）|
-| 数据 | `memory.db`（对话）+ `vectors.db`（向量）|
-| API | `http://127.0.0.1:8420/` |
-| 小唯调用 | daemon.py 通过 `/capture` 和 `/recall` 写入/读取 |
-
-### 参考项目
-
-| 仓库 | 用途 |
-|------|------|
-| `xiaoxue_admin/agent-memory-skill` | tier 分层、线性衰减架构参考 |
-| `xiaoxue_admin/memory-os` | 7层记忆操作系统架构参考 |
-
----
-
-## 安装顺序
-
-```
-第一步：织忆（底层）
-  ↓
-第二步：TencentDB（对话存储）
-  ↓
-第三步：小唯系统（上层应用，包含 Soulful）
-```
-
-**安装顺序：织忆 → TencentDB → 小唯系统。** 三者通过 HTTP API 互联，代码完全解耦。
-
----
-
-## 架构依赖
-
-```
-小唯系统(daemon.py)
-├── /capture (TencentDB)    ← L3/L4 scenes 存储
-│   └── session_key + user_content + assistant_content
-├── http://127.0.0.1:7821  ← 织忆 L1/L2 recall
-│   └── X-API-Key: zhiyi-dev-key-2026
-├── ~/.hermes/soulful/     ← Soulful L5/L6 读写
-│   └── cares + heart-traces + user-profile
-└── → 统一写入 ~/.hermes/llm_context.json（L7）
-```
-
-| 项目 | 仓库 | 定位 | 依赖关系 |
-|------|------|------|---------|
-| **织忆 memoryweave** | `xiaoxue_admin/memoryweave` | 底层存储引擎（zhiyid + LanceDB + bge-embed）| 被依赖方 |
-| **小唯 xiaowei-system** | `xiaoxue_admin/xiaowei-system` | 上层应用（daemon + cron + 记忆蒸馏）| 依赖方 |
-
-**安装顺序：先织忆，再小唯系统。** 小唯系统通过 `localhost:7821` 调用织忆 API。
+## 快速开始
 
 ```bash
-# 小唯系统调用织忆示例
-curl -s -H "X-API-Key: zhiyi-dev-key-2026" \
-  -d '{"query":"牧尘偏好","top_k":3}' \
-  http://127.0.0.1:7821/api/v1/recall
+# 构建
+make build
+
+# 安装
+sudo make install
+
+# 验证
+curl http://localhost:7821/health
 ```
 
----
+## 文档
 
-## 架构总览
+- [设计文档](DESIGN.md) — 完整架构设计 v3.8
+- [实施计划](IMPLEMENTATION.md) — 里程碑与任务
+- [API 参考](docs/api.md)
 
-```
-┌──────────────────────────────────────────────────────────────┐
-│                     Hermes Agent (Plugin)                     │
-│   plugins/memory/zhiyi/ — 7 tools + 自动注入 + 社交关闭      │
-└──────────────────────────┬───────────────────────────────────┘
-                           │ HTTP (localhost:7821)
-                           ▼
-┌──────────────────────────────────────────────────────────────┐
-│  zhiyid (Go daemon, port 7821)                                │
-│                                                               │
-│  ┌─────────────┐  ┌──────────────┐  ┌──────────────────────┐ │
-│  │  REST API    │  │   蒸馏引擎    │  │  冲突治理 / 缺口检测  │ │
-│  │  ~84 端点    │  │  distill/    │  │  conflict + gap     │ │
-│  └──────┬──────┘  └──────┬───────┘  └──────────────────────┘ │
-│         │                │                                    │
-│         │     ┌──────────▼───────────┐                        │
-│         │     │  SQLiteGraphStore    │                        │
-│         │     │  (7014 节点/61058 边)│                        │
-│         │     └──────────────────────┘                        │
-│         │                                                     │
-│         │  Unix Socket (/tmp/zhiyi-ipc.sock)                  │
-└─────────┼─────────────────────────────────────────────────────┘
-          ▼
-┌──────────────────────────────────────────────────────────────┐
-│  zhiyi-consolidate (Rust sidecar)                             │
-│                                                               │
-│  ┌──────────────┐  ┌──────────────┐  ┌────────────────────┐  │
-│  │  LanceDB 原生 │  │ DBSCAN 聚类  │  │  Embedding +      │  │
-│  │  读写         │  │ 衰减回归      │  │ Rerank 管线       │  │
-│  └──────┬───────┘  └──────────────┘  └────────────────────┘  │
-│         ▼                                                     │
-│  ┌─────────────────────────────────────┐                      │
-│  │  /var/lib/memoryweave/ (LanceDB)    │                      │
-│  │  memories: 3510 条 / episodes: 73   │                      │
-│  └─────────────────────────────────────┘                      │
-└──────────────────────────────────────────────────────────────┘
-
-┌──────────────────────────┐
-│  bge-embed (port 8000)   │ ← Python ONNX 推理
-│  BGE-M3 embedding 服务    │
-└──────────────────────────┘
-```
-
-### 语言分工
+## 语言分工
 
 | 组件 | 语言 | 原因 |
 |------|------|------|
 | HTTP API + 业务逻辑 | Go | goroutine 高并发，单二进制 |
 | LanceDB + 向量管线 | Rust | 原生 `lancedb` crate，零 FFI |
-| Embedding 推理 | Python (ONNX) | BGE-M3 模型，最佳推理生态 |
-| Hermes 插件 | Python | Hermes MemoryProvider 接口 |
+| Embedding/Rerank | Rust | Candle/ort 推理 |
 
----
+## 仓库
 
-## 功能特性
-
-### 语义记忆（commit / recall）
-
-```
-POST /api/v1/commit   — 提交记忆（需 agent_id + content）
-POST /api/v1/recall   — 语义检索（支持 hybrid / keyword / semantic 三模式）
-```
-
-- 1024 维向量嵌入（BGE-M3）
-- MMR diversity 默认 0.3，结果去重
-- freshness 生命周期：`fresh` → `verified`
-- 支持 namespace 隔离
-
-### 知识图谱（Navigate / Stats）
-
-```
-POST /api/v1/graph/navigate  — BFS 节点关系遍历
-GET  /api/v1/graph/stats     — 图谱统计
-POST /api/v1/graph/query     — 精确边查询
-GET  /api/v1/graph/pagerank  — PageRank 排序
-```
-
-- SQLite 存储，7014 节点 / 61058 边
-- 自动实体归一化（`n_` 前缀）
-- 按关系类型分组 + 推荐探索建议
-- 自然语言查询（`nl_query`）
-
-### P0 — Recall 降级策略
-
-当 bge-embed (8000) 或 Rust IPC sidecar 不可用时，recall 自动降级到 graph.db 关键词搜索（FallbackTextSearch），返回 `X-Fallback: graph` 响应头。保证单点故障不导致全挂。
-
-### P1 — 自动注入钩子 + 社交关闭
-
-- `queue_prefetch` 后台线程自动查织忆 + 缓存（TTL 30s）
-- 社交关闭检测：短消息、纯社交用语（"好的" / "ok" / "👍"）跳过注入
-- 输出标记：`[织忆 Memory]` / `[织忆 Graph]`
-- 无缝融入 Hermes 对话流
-
-### P2 — 信任评分
-
-`graph_edges` 表新增三列：
-
-| 列名 | 类型 | 默认值 | 说明 |
-|------|------|--------|------|
-| `trust_score` | REAL | 0.5 | 信任评分（贝叶斯先验） |
-| `retrieval_count` | INTEGER | 0 | 被检索次数 |
-| `helpful_count` | INTEGER | 0 | 被标记有用次数 |
-
-评分公式：`trust_score = helpful_count / retrieval_count`（retrieval_count > 0 时）
-
-### P3 — CREATIVE.md 隔离
-
-`~/.hermes/CREATIVE.md` 存储织忆工作记忆，插件 `system_prompt_block()` 自动加载标注为 `[织忆 工作记忆]`（Ground Truth level 2），解决 memory 工具与织忆 plugin 的双写入冲突。
-
-### P4 — Ground Truth Prompt
-
-SOUL.md 定义 4 级权威层级：
-
-1. **Terminal 实时输出** — curl / 工具调用真实结果
-2. **注入记忆** — `[织忆 Memory]` / `[织忆 Graph]`（插件注入）
-3. **项目官方文档** — `docs/` / README / INSTALL
-4. **训练知识** — 模型权重中存储的通用知识
-
-低层级不可推翻高层级。另有记忆反馈规则确保信任评分闭环。
-
-### P5 — Wiki 策展管线
-
-`scripts/wiki_curator.py` 自动知识库管线：
-
-- 扫描 `~/mc/` 下 `.md` 文件，SHA-256 diff 跟踪
-- 启发式提取：headings → 概念，bold / key phrases → 实体
-- 写入织忆：概念 `/commit`（category=wiki），关系 `/graph/edge`
-- 支持 `--dry-run`（预览）、`--force`（全量）、`--llm`（LLM 增强）
-- 跳过 <500 字符文件和 `_` 前缀文件
-
-### H1-H6 精度优化
-
-| 编号 | 优化 | 状态 |
-|------|------|------|
-| H1 | BM25 关键词评分（0.7 向量 + 0.3 关键词融合） | ✅ |
-| H2 | LLM Wiki 策展（--llm 模式，回退启发式） | ✅ |
-| H3 | 自动信任评分（recall 后异步 UpdateEdgeTrustScores） | ✅ |
-| H4 | 默认 MMR diversity = 0.3 | ✅ |
-| H5 | 三模式搜索：hybrid / keyword / semantic | ✅ |
-| H6 | 多级存储：LanceDB → SQLite → 内存三级降级 | ✅ |
-
-### cli-anything 命令行伴侣
-
-织忆原生集成 cli-anything 框架，将 Go 和 Rust API 封装为 CLI 子命令。支持：
-
-- `zhiyi commit` / `zhiyi recall` — 记忆操作
-- `zhiyi navigate` / `zhiyi stats` — 图谱查询
-- `zhiyi health` — 健康检查
-- 详见 `cli-anything/` 目录
-
-### rag-skill 渐进式检索（新增）
-
-三段式检索架构：
-
-```
-用户查询 → keyword 粗筛 → semantic 精排 → rerank 重排序
-```
-
-- 粗筛层：BM25 关键词倒排索引，快速缩减候选集
-- 精排层：BGE-M3 语义嵌入，向量相似度排序
-- 重排序层：cross-encoder rerank，微调 top-K 结果
-- 默认返回 top-K 结果，支持 `top_k` 参数调优
-
----
-
-## 快速开始
-
-### 前置依赖
-
-- Go 1.21+
-- Rust 1.75+（仅需构建 zhiyi-consolidate）
-- Redis 7.0+（可选，默认降级为内存模式）
-- Python 3.10+（bge-embedding 服务）
-
-### 构建
-
-```bash
-# 克隆
-git clone http://192.168.123.11:3000/xiaoxue_admin/memoryweave.git
-cd memoryweave
-
-# 构建 Go daemon（zhiyid）
-make build
-
-# 构建 Rust sidecar（可选）
-make build-rust
-
-# 构建 CLI 工具
-make build-cli
-```
-
-### 运行
-
-```bash
-# 方式一：直接运行
-~/.local/bin/zhiyid
-
-# 方式二：systemd（用户级，推荐）
-systemctl --user enable --now zhiyid
-systemctl --user enable --now bge-embed
-systemctl --user enable --now zhiyi-consolidate
-curl http://localhost:7821/health
-
-# 方式三：Docker
-docker compose up -d
-curl http://localhost:7821/health
-```
-
-### 验证完整链路
-
-```bash
-# 1) 健康检查
-curl -s -H "X-API-Key: zhiyi-dev-key-2026" http://localhost:7821/api/v1/health
-
-# 2) 提条记忆试试
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" \
-  -H "Content-Type: application/json" \
-  -d '{"agent_id":"a06","content":"Hello 织忆","metadata":{"source":"test"}}' \
-  http://localhost:7821/api/v1/commit
-
-# 3) 搜一下
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" \
-  -H "Content-Type: application/json" \
-  -d '{"query":"织忆","top_k":3}' \
-  http://localhost:7821/api/v1/recall
-
-# 4) 图谱统计
-curl -s -H "X-API-Key: zhiyi-dev-key-2026" http://localhost:7821/api/v1/graph/stats
-```
-
-### Hermes 插件安装
-
-```bash
-cp -r plugins/hermes-zhiyi ~/.hermes/hermes-agent/plugins/memory/zhiyi
-uv pip install websocket-client
-cd ~/.hermes/hermes-agent
-python3 -c "from plugins.memory.zhiyi import HermesZhiYiMemoryProvider; \
-  p = HermesZhiYiMemoryProvider(); \
-  print(f'可用: {p.is_available()}, 工具数: {len(p.get_tool_schemas())}')"
-```
-
----
-
-## 配置参考
-
-### 环境变量
-
-| 变量 | 默认值 | 说明 |
-|------|--------|------|
-| `PORT` | `7821` | API 监听端口 |
-| `STORAGE_BACKEND` | `lancedb` | 存储后端：`lancedb` / `sqlite` / `memory` |
-| `SQLITE_PATH` | `/var/lib/memoryweave/memoryweave.db` | SQLite 数据库路径 |
-| `LANCEDB_SOCKET` | `/tmp/zhiyi-ipc.sock` | Rust IPC socket 路径 |
-| `GRAPH_PATH` | `/var/lib/memoryweave/graph.db` | 图谱数据库路径 |
-| `API_KEY` | — | API 认证密钥 |
-| `VLLM_ENDPOINT` | — | Embedding 模型端点 |
-| `BGE_MODEL_DIR` | — | BGE-M3 ONNX 模型目录 |
-| `RERANK_ENDPOINT` | — | Rerank 模型端点 |
-| `LLM_ENDPOINT` | — | LLM 端点（蒸馏/自动修复用） |
-| `LLM_MODEL` | — | LLM 模型名称 |
-| `LLM_API_KEY` | — | LLM API Key |
-| `STATIC_DIR` | 内置静态文件 | Web UI 静态文件目录 |
-| `ZHIYI_WEB_UI_ROOT` | 内置 HTML | Web UI 入口路径 |
-
----
-
-## API 速查表
-
-> 所有 `/api/v1/*` 接口需要 Header: `X-API-Key: ***`
-
-### 健康检查
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/health` | 健康检查（无认证） |
-| GET | `/api/v1/health` | 健康检查（需认证） |
-
-### 核心记忆
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| POST | `/api/v1/commit` | 提交记忆 |
-| POST | `/api/v1/recall` | 语义检索（支持 mode=hybrid\|keyword\|semantic） |
-| POST | `/api/v1/batch-commit` | 批量提交 |
-| GET | `/api/v1/memories` | 列出记忆（分页） |
-| POST | `/api/v1/feedback/useful` | 标记记忆有用（GA-P0-1 写 human_useful） |
-| POST | `/api/v1/feedback/not-useful` | 标记记忆无用（写 human_not_useful_count） |
-| POST | `/api/v1/feedback/deprecate` | 标记过时 |
-| POST | `/api/v1/feedback/correct` | 提交修正 |
-
-### 统计
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/api/v1/stats` | 系统统计（total_memories, episodes 等） |
-
-### 知识图谱
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/api/v1/graph/stats` | 图谱统计（节点数 / 边数 / 密度） |
-| POST | `/api/v1/graph/navigate` | BFS 节点遍历（entity + max_hops） |
-| POST | `/api/v1/graph/query` | 精确边查询 |
-| POST | `/api/v1/graph/nl_query` | 自然语言图谱查询 |
-| POST | `/api/v1/graph/edge` | 添加关系边 |
-| POST | `/api/v1/graph/edge/feedback` | 边信任评分反馈 |
-| GET | `/api/v1/graph/pagerank` | PageRank 节点排名 |
-| POST | `/api/v1/graph/export` | 导出图谱 |
-| POST | `/api/v1/graph/cleanup` | 脏数据清理（支持 dry_run） |
-| GET | `/api/v1/cache/stats` | 图谱缓存命中率 |
-
-### WebSocket
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| WS | `/api/v1/ws/{agent_id}` | 实时记忆流订阅 |
-
-### 管理接口
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| POST | `/api/v1/admin/consolidate` | 手动触发记忆整合 |
-| POST | `/api/v1/admin/forget` | 删除记忆 |
-| POST | `/api/v1/admin/backup` | 创建备份 |
-| GET | `/api/v1/admin/backups` | 列出备份 |
-| POST | `/api/v1/admin/restore` | 恢复备份 |
-| POST | `/api/v1/admin/distill/force` | 强制蒸馏 |
-| GET | `/api/v1/admin/audit` | 审计日志 |
-
-### 冲突治理
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/api/v1/conflicts` | 列出记忆冲突 |
-| POST | `/api/v1/conflicts/resolve` | 解决冲突 |
-
-### 缺口检测
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/api/v1/gaps` | 列出记忆缺口 |
-| POST | `/api/v1/gaps/detect` | 检测缺口 |
-| POST | `/api/v1/gaps/repair` | 修复缺口 |
-| POST | `/api/v1/gaps/close/{id}` | 关闭缺口 |
-
-### 蒸馏管理
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/api/v1/distill/status` | 蒸馏状态 |
-| GET | `/api/v1/distill/queue` | 蒸馏队列 |
-| GET | `/api/v1/distill/quota` | 蒸馏配额 |
-
-### L3 世界模型
-
-| 方法 | 路径 | 说明 |
-|------|------|------|
-| GET | `/api/v1/l3/worldmodel` | 获取世界模型 |
-| POST | `/api/v1/l3/worldmodel` | 更新世界模型 |
-
----
-
-## 目录结构
-
-```
-memoryweave/
-├── go/                          # Go daemon（zhiyid）
-│   ├── cmd/zhiyid/              # 主入口
-│   ├── internal/
-│   │   ├── api/                 # HTTP 路由 + 端点（~84 端点）
-│   │   │   └── routes/          # 路由实现（core, graph, ws, l3, ...）
-│   │   ├── governance/          # 冲突治理、图谱存储、自动扩展
-│   │   ├── storage/             # 存储引擎（lancedb, sqlite, redis, recall, ...）
-│   │   ├── models/              # 数据模型
-│   │   ├── distill/             # 蒸馏引擎
-│   │   ├── consolidate/         # 记忆整合客户端
-│   │   ├── selfoptimize/        # 自优化管线
-│   │   ├── distributed/         # 分布式支持
-│   │   └── metrics/             # 监控指标
-│   └── zhiyid-new               # 编译产物
-├── rust/                        # Rust sidecar（zhiyi-consolidate）
-│   └── src/
-│       ├── main.rs              # IPC 监听 + 调度
-│       ├── lancedb_ops.rs       # LanceDB 原生读写
-│       ├── embed.rs             # Embedding 推理
-│       ├── rerank.rs            # Rerank 管道
-│       ├── cluster.rs           # DBSCAN 聚类
-│       ├── decay_calibrate.rs   # 衰减校准
-│       ├── graph_prune.rs       # 图谱剪枝
-│       ├── quality_backtrace.rs # 质量回溯
-│       └── report.rs            # 报告生成
-├── plugins/
-│   ├── hermes-zhiyi/            # Hermes MemoryProvider 插件（7 工具）
-│   │   └── __init__.py          # v1.1.0: 自动注入 + 社交关闭
-│   └── obsidian/                # Obsidian 侧边栏插件
-├── scripts/                     # 运维脚本
-│   ├── wiki_curator.py          # P5 Wiki 策展管线
-│   ├── three-way-check.sh       # 三方交叉健康检查
-│   ├── verify-p0p1p2.sh         # P0/P1/P2 一键验证
-│   └── daily-check.sh           # 每日巡检
-├── deploy/                      # 部署配置
-│   └── systemd/                 # systemd service 文件
-│       ├── zhiyid.service
-│       ├── bge-embed.service
-│       └── zhiyi-consolidate.service
-├── cli-anything/                # CLI 命令行伴侣集成
-├── carriers/                    # 载体（Obsidian / 飞书等）
-├── proto/                       # Protocol Buffers 定义
-├── web-ui/                      # Web 管理界面
-├── docs/                        # 设计文档 / 方案文档
-├── tests/                       # 集成测试
-├── backups/                     # 备份目录
-├── skills/                      # Hermes skills 定义
-├── docker-compose.yml           # Docker 编排
-├── Makefile                     # 构建入口
-├── DESIGN.md                    # 完整架构设计（v3.8）
-├── INSTALL.md                   # systemd 详细安装步骤
-├── BENCHMARK.md                 # 性能基准测试
-└── VERSION                      # 版本文件
-```
-
----
-
-## 运维
-
-### 进程管理
-
-```bash
-# 查看所有相关进程
-ps aux | grep -E 'zhiyi|bge' | grep -v grep
-
-# 查看端口
-ss -tlnp | grep -E '7821|8000'
-```
-
-### systemd 操作
-
-```bash
-# 状态检查
-systemctl --user status zhiyid
-systemctl --user status bge-embed
-systemctl --user status zhiyi-consolidate
-
-# 日志
-journalctl --user -u zhiyid -f
-journalctl --user -u bge-embed -f
-journalctl --user -u zhiyi-consolidate -f
-
-# 重启
-systemctl --user restart zhiyid
-```
-
-### 健康检查
-
-```bash
-# 一键三方交叉验证（进程 + 端口 + 端点）
-bash scripts/three-way-check.sh
-
-# 或手动
-curl -s -H "X-API-Key: zhiyi-dev-key-2026" http://localhost:7821/api/v1/health
-curl -s http://localhost:8000/health  # bge-embed
-```
-
-### 日志位置
-
-| 进程 | 日志 |
-|------|------|
-| zhiyid | `/tmp/zhiyid.log` / `journalctl --user -u zhiyid` |
-| Rust sidecar | `/tmp/zhiyi-sidecar.log` / `journalctl --user -u zhiyi-consolidate` |
-| bge-embed | `journalctl --user -u bge-embed` |
-
----
-
-## 相关项目
-
-- **Hermes Agent** — 织忆的主要消费者。通过 `memory.provider: zhiyi` 配置自动集成 7 个记忆工具。
-- **OpenClaw** — 第二消费者。通过 `openclaw-zhiyi-plugin/` 集成织忆记忆。
-- **Obsidian** — 知识管理前端。通过 `plugins/obsidian/` 侧边栏插件交互。
-- **cli-anything** — 命令行伴侣。将织忆 API 封装为 CLI 子命令。
-- **Memory-OS** — 竞品对比参考（7 层记忆架构）。详见 `docs/memory-os-7-layer-comparison.md`。
-
----
-
-## 文档
-
-- [DESIGN.md](DESIGN.md) — 完整架构设计 v3.8
-- [INSTALL.md](INSTALL.md) — systemd 详细安装步骤
-- [Makefile](Makefile) — 构建入口（`make build` / `make build-rust` / `make build-cli`）
-- [docker-compose.yml](docker-compose.yml) — Docker 编排
-- [BENCHMARK.md](BENCHMARK.md) — 性能基准
-- [docs/](docs/) — 方案文档与竞品分析
+Gitea: http://192.168.123.11:3000/xiaoxue_admin/memoryweave

WORKLOG.md

@@ -1,338 +0,0 @@
-# 织忆系统修复工作记录
-
-> 维护者：小唯 A06
-> 创建：2026-05-30
-> 最新更新：2026-06-02
-
-## G7 E3 自优化闭环完成 (2026-06-02)
-| 组件 | 状态 | 验证 |
-|------|------|------|
-| GetSkillCandidates (candidates) | ✅ | 返回 20 条候选（min_recall=5 过滤），Rust IPC lancedb_query |
-| crystallize 端点 | ✅ | 返回 eta=0.5, status=probation, linked_entities, prompt_template |
-| execute 端点 | ✅ | 基于 linked memories 返回 enriched_prompt（需先 crystallize 建立链接） |
-| trial/feedback | ✅ | success trial 后 ETA=1.0→0.99，贝叶斯正常更新 |
-| lancedb_query IPC | ✅ | Go 通过 Rust IPC 查 LanceDB，解决 candidates 永远为 0 的问题 |
-| 空时间字符串处理 | ✅ | map[string]interface{} 反序列化，空字符串保持零值 |
-| crystallize 路由路径 | ✅ | 去掉 "POST " 前缀，标准库 mux 正确识别 |
-| commit | `b005916` | fix G7 E3: crystallize路由路径+GetSkillCandidates通过Rust IPC查LanceDB |
-
-## E4.3 Bug Fix (2026-06-01)
-| 问题 | 根因 | 修复 |
-|------|------|------|
-| ShouldForget 的 degree 参数始终为 0 | admin.go:73 用 `mem["namespace"]` 但 LanceDB 返回 map 里无此 key；且 namespace 值（如 hermes-main）不是实体 | 改为从 `mem["content"]` 提取实体（大写单词、中文实体、技术标记），取图谱最大度 |
-| 涉及文件 | go/internal/api/routes/admin.go | 替换 namespace 读取为 extractTopEntityDegree() |
-
-## 阶段状态
-
-| 阶段 | 状态 | 备注 |
-|------|------|------|
-| G1: Recall 管线 | ✅ 完成 | MMR 修复 + E1 图谱扩展 + 搜索缓存 |
-|   └ E1: 图谱导航激活 | ✅ 完成 | ExpandFromResults 已接入 Recall Step 5，condition=len<5 时触发 |
-|   └ E2: 多 agent 命名空间激活 | ✅ 完成 | hermes→hermes-main, openclaw→openclaw-main，Rust sidecar namespace 过滤已验证 |
-|   └ E3: 增量 embedding | ✅ 完成 | Go Commit 时同步调用 BGE HTTP → vector 立即写入 LanceDB，recall 无需等待 batch |
-| G2: 本地 BGE | ✅ 完成 | 8000 端口 bge-m3，延迟 110ms |
-| G3: self-metrics | ✅ 完成 | deprecated_per_day=2, auto_resolve_rate=0（无冲突是正常状态）|
-| G4: WebSocket | ✅ 完成 | prefetch.push + consolidation.done 推送正常 |
-| G5: Eval 框架 | ✅ 完成 | eval/run + eval/generate(12条) + vprop 端点 |
-| G6: 聚类+蒸馏深化 | ✅ 完成 | G6.1 DBSCAN + G6.2 LLM质量回溯 + G6.3 L2 Patterns + gap |
-| G7: 遗忘 + 技能系统 | ✅ 完成 | E4.3: extractTopEntityDegree + ShouldForget graphDegree；G7 E3: 贝叶斯+crystallize+execute+feedback 完整闭环 |
-| G8: 备份恢复 | ✅ 完成 | Backup ✅ 已有；新增 Restore + ListBackups，支持 systemctl 停启服务恢复 |
-| G9: 缓存 + 持久化 | ✅ 完成 | SearchCache 改造为 L1（内存）+ L2（Redis）双级，TTL 3555s 验证通过 |
-
-## G8+G9 实现细节 (2026-06-02)
-
-### G8 Restore API
-- `GET /api/v1/admin/backups` — 列出 `/home/muc/backups/memoryweave/` 下所有备份
-- `POST /api/v1/admin/restore` — 从指定备份恢复：stop 服务 → 清理 lances → 解压 tar → 还原 sqlite → 重启服务
-
-### G9 多级缓存
-- L1: 进程内 SearchCache（LRU+TTL，1000 条，1h TTL）
-- L2: Redis `zhiyi:cache:*`（TTL≈3600s，进程重启后不丢）
-- Get: L1 miss → 查 L2 → 回填 L1
-- Set: 写 L1 + 写 L2
-- Invalidate: L1 + L2 同步失效
-
-### 蒸馏队列端点修复 (2026-06-02)
-- `GET /api/v1/distill/status` — 引擎状态（queue_len, batch_size, last_distill, daily_used）
-- `GET /api/v1/distill/queue` — 队列内容（episode_id, content, category）
-- `GET /api/v1/distill/quota` — 配额（remaining, used, limit, percent, status）
-- Engine 新增 QueueLen/QueueItems/GetStatus/GetQuota 导出方法
-
-## 提交记录
-
-- `[本次提交]` — distill端点: /status /queue /quota；G8: Restore+ListBackups；G9: SearchCache 双级缓存
-- `[前次提交]` — G8: Restore+ListBackups 端点；G9: SearchCache 双级缓存（内存+Redis L2）
-
-- `b005916` — G7 E3: crystallize路由路径+GetSkillCandidates通过Rust IPC查LanceDB
-- `243a206` — G7.3: skill execute + quality_score fix
-- `43286dd` — G7.1+G7.2: skill persistence + crystallize API
-- `cd0f898` — G6: eps=1.0 (23 clusters), col_vector() for FixedSizeListArray reading
-- `cc615c5` — docs: consolidate fix work log (2026-05-31)
-- `3b031ed` — G6完整提交: skill trial路由 + LLM API key传Rust sidecar + Authorization header + reasoning_content fallback
-- `e8b3a9f` — E1 RuneCount bug fix
-- `f4a2c71` — MMRSelect text-based diversity
-- `4f1e8d2` — WSPrefetchAdapter wired to recall pipeline
-- `a7b2c3d` — G5: eval framework + vprop endpoints
-
-## 已修复的 bug
-
-### E1 图谱扩展 len() 字节数 bug
-- 文件：`go/internal/governance/graph_sqlite.go`
-- `len(chinese)` → `utf8.RuneCountInString(chinese)`
-- 提交: `e8b3a9f`
-
-### G6.2 LLM 质量回溯修复（2026-05-31）
-- **问题1**：API key 有 `sk-` 前缀 → 修正为 `0ExNiL...`（无前缀）
-- **问题2**：MiniMax M2.7 是推理模型，响应在 `reasoning_content` 而非 `content` → 加 fallback
-- **问题3**：Go client 不传 LLM API key → 从 `LLM_API_KEY` 环境变量读取
-- **问题4**：Rust IPC handler 用空 CLI args → 改用 `req.llm_endpoint`
-- **模型切换**：MiniMax M2.7 → Qwen3.5-122B（速度 2s，更稳定）
-- 提交: `3b031ed`
-
-### G6.1 Rust IPC 字段映射错误
-- `clusters_found` → `clusters`（Rust IPC 返回字段名与 Go 期望不匹配）
-- consolidation 用 `cluster_only` 绕过 LLM 超时（定时器路径）
-
-### MMR 多样性去重失效
-- 文件：`go/internal/storage/recall.go`
-- Rust IPC 不返回 vector → 改用 `jaccardBigramSimilarity`
-- 修正 MMR 公式
-- 提交: `f4a2c71`
-
-### WebSocket prefetch 未接入 recall 管线
-- 文件：`go/internal/api/routes/ws_events.go` + `core.go`
-- 新增 `WSPrefetchAdapter` 实现 `storage.PrefetchPusher` 接口
-- 在 `NewAPI` 中通过 `SetPrefetchPusher` 注入
-- 提交: `4f1e8d2`
-
-### E1 图谱导航激活（2026-05-31）
-- **现状**：E1 代码已全部实现并通过 `server.go:112` 接入 `RecallPipeline.SetGraphExpander(graphStore)`
-- **触发条件**：`recall.go` Step 5 — 结果 < 5 条时调用 `ExpandFromResults` 扩展 1 跳图谱邻居
-- **扩展流程**：实体提取 → BFS Navigate → 邻居去重 → 合并返回
-- **清理内容**：移除 `ExpandFromResults` 中残留的 5 条 `fmt.Printf("[E1] ...")` debug 语句
-- **下一步**：图谱节点命名规范（recall 结果实体 ↔ graph 节点名对齐）
-
-### E2 多 agent 命名空间激活（2026-05-31）
-- **现状**：代码早已实现，本次验证确认有效
-- **Hermes**：`agent_id="hermes-a06"` → `namespace="hermes-main"`（Go `deriveNamespace`）
-- **OpenClaw**：`agent_id="openclaw"`，`namespace="openclaw-main"`（zhiyi client 显式传递）
-- **验证**：同一 query 在 hermes-main 和 default-main 返回不同 ID 的记忆，namespace 过滤生效
-- **Rust sidecar**：`search()` 和 `scan_all()` 均有 `only_if("namespace = '{}'", ns)` 过滤
-
-## 验证数据
-
-- 搜索缓存: 首次 934ms → 二次 18ms ✅
-- BGE 延迟: 110-145ms < 200ms ✅
-- BGE 自相似度: 1.0 ≥ 0.99 ✅
-- WebSocket prefetch: 第 2 次 recall 后触发 ✅
-- WebSocket consolidation.done: 直接触发 ✅
-- LLM 速度测试（Qwen3.5-122B）: 2076ms ✅
-- Consolidation full 路径: 3.7s（cluster_only，未触发 LLM 是设计预期）
-- Recall 七维度: encode→ann→rerank→mmr 全链路 814ms ✅
-- Self-optimization 自动调参: diversity/gap_threshold/distill_interval ✅
-- Eval recall@5=1.0, MRR=1.0, nDCG=1.0 ✅
-
-## 服务拓扑
-
-### 进程与服务
-
-| 服务 | 二进制路径 | 端口/Socket | systemd 服务 | 用途 |
-|------|-----------|-------------|--------------|------|
-| **zhiyid** | `~/.local/bin/zhiyid` | `7821`(HTTP) | `zhiyid.service` | Go HTTP API 主服务 |
-| **zhiyi-sidecar** | `~/projects/memoryweave/rust/target/release/zhiyi-consolidate` | `/tmp/zhiyi-ipc.sock` | `zhiyi-sidecar.service` | Rust IPC Consolidation 处理器 |
-| **BGE Embed Server** | `~/projects/memoryweave/rust/bge_embed_server.py` | `8000` | `bge-embed.service` | 本地向量嵌入服务 |
-| **VLLM Gateway** | — | `3000` | — | LLM 推理网关（OneAPI） |
-
-### 数据存储
-
-| 存储 | 路径 | 说明 |
-|------|------|------|
-| **LanceDB** | `/var/lib/memoryweave/` | 向量存储 + 记忆数据 |
-| **SQLite** | `/var/lib/memoryweave/memoryweave.db` | 结构化关系数据 |
-| **Graph DB** | `/var/lib/memoryweave/graph.db` | 知识图谱 |
-| **IPC Socket** | `/tmp/zhiyi-ipc.sock` | Go → Rust 通信 |
-
-### LLM 配置
-
-| 参数 | 值 |
-|------|-----|
-| ENDPOINT | `http://127.0.0.1:3000/v1/chat/completions` |
-| MODEL | `qwen/qwen3.5-122b-a10b` |
-| API KEY | `0ExNiL...MWBP`（无 sk- 前缀） |
-
-### BGE 配置
-
-| 参数 | 值 |
-|------|-----|
-| ENDPOINT | `http://127.0.0.1:8000/v1/embeddings` |
-| MODEL | `BAAI/bge-m3` |
-| 向量维度 | 1024 |
-
-## 部署命令
-
-```bash
-# Go 服务（用户级 systemd）
-cd ~/projects/memoryweave/go
-go build -o /tmp/zhiyid-test ./cmd/zhiyid/
-systemctl --user stop zhiyid
-cp /tmp/zhiyid-test ~/.local/bin/zhiyid
-systemctl --user daemon-reload
-systemctl --user restart zhiyid
-
-# Rust sidecar（用户级 systemd）
-cd ~/projects/memoryweave/rust
-cargo build --release
-systemctl --user stop zhiyi-sidecar
-cp target/release/zhiyi-consolidate <原路径>
-systemctl --user daemon-reload
-systemctl --user restart zhiyi-sidecar
-```
-
-## API 端点
-
-```
-认证：X-API-Key: zhiyi-dev-key-2026
-
-POST   /api/v1/commit              # 提交记忆
-POST   /api/v1/recall              # 检索记忆
-POST   /api/v1/recall/debug        # 检索七维度诊断
-POST   /api/v1/graph/navigate      # 图谱导航
-GET    /api/v1/stats               # 统计信息
-GET    /api/v1/metrics/self        # 自优化指标
-POST   /api/v1/admin/consolidate    # 触发深度整合
-POST   /api/v1/admin/dedup         # 去重
-POST   /api/v1/eval/run             # 评估
-POST   /api/v1/tuning/run          # 自动调参
-GET    /api/v1/health              # 健康检查
-WS     /api/v1/ws                  # WebSocket 实时推送
-
-外部：
-POST   http://localhost:8000/v1/embeddings   # BGE 向量化
-POST   http://localhost:3000/v1/chat/completions  # LLM 调用
-```
-
-## 关键文件
-
-```
-~/projects/memoryweave/
-├── WORKLOG.md              # 本文件
-├── REPAIR-FULL.md          # 修复计划总表
-├── go/
-│   ├── cmd/zhiyid/main.go
-│   ├── internal/
-│   │   ├── api/routes/
-│   │   │   ├── core.go     # NewAPI（含 SetPrefetchPusher 接入）
-│   │   │   └── ws_events.go # WSPrefetchAdapter
-│   │   ├── governance/graph_sqlite.go # E1 bug 修复
-│   │   └── storage/
-│   │       └── recall.go   # MMR bigram 修复
-```
-
-## 下一步
-
-- **E4**：图谱推理（图谱真正参与推理：矛盾检测、跨 agent 共享、遗忘决策参考图谱结构）
-- **G7**：遗忘 + 技能系统（forgetter + agent skills）
----
-
-## 2026-05-31 紧急修复：consolidate 服务路径冲突
-
-### 问题
-
-监控报告 `lancedb` 目录为空，实际数据在 `/var/lib/memoryweave/memories.lance/`（1386 条）。
-
-### 根因
-
-**两个问题叠加：**
-
-1. **系统级 service 文件路径错误**：`/etc/systemd/system/zhiyi-consolidate.service` 指向：
-   - binary: `/usr/local/bin/zhiyi-consolidate`（旧 binary，5月29日）
-   - data-dir: `/var/lib/memoryweave/lancedb`（空目录）
-
-2. **多进程冲突**：同时存在 3 个 consolidate 进程，路径各异
-
-### 修复
-
-```bash
-# 1. 修复系统 service 文件
-cat > /etc/systemd/system/zhiyi-consolidate.service << 'SERVICE'
-[Unit]
-Description=ZhiYi Consolidation Engine (Rust LanceDB)
-After=network.target
-
-[Service]
-Type=simple
-User=muc
-ExecStart=/home/muc/projects/memoryweave/rust/target/release/zhiyi-consolidate --socket /tmp/zhiyi-ipc.sock --data-dir /var/lib/memoryweave
-Restart=always
-RestartSec=5
-
-[Install]
-WantedBy=multi-user.target
-SERVICE
-
-# 2. 重载并重启
-sudo -S -p '' systemctl daemon-reload
-sudo -S -p '' systemctl restart zhiyi-consolidate
-```
-
-### 验证
-
-```
-$ curl -s -H "X-API-Key: zhiyi-dev-key-2026" "http://127.0.0.1:7821/api/v1/stats"
-{"backend":"lancedb (Rust IPC)","data_dir":"/var/lib/memoryweave","tombstone_count":0,"total_episodes":1,"total_memories":1388}
-```
-
-**数据完好，1388 条 memories。**
-
-### 经验教训
-
-- 部署 binary 时**必须同步更新 systemd service 文件**，不能只替换 binary
-- 两个 service 文件需保持同步：`~/.config/systemd/user/zhiyi-consolidate.service` 和 `/etc/systemd/system/zhiyi-consolidate.service`
-- 监控系统检查的路径必须和实际运行的进程路径一致
-
-
----
-
-## E5.1 Obsidian 插件（2026-06-02）
-
-### 实现内容
-
-**CORS 中间件**
-- `go/internal/api/middleware/cors.go`: 新增 `CORS()` 函数，支持 `app://obsidian.md` origin
-- `go/internal/api/server.go`: `return middleware.CORS()(middleware.Auth(mux))`
-- 验证: `curl -I -X OPTIONS http://localhost:7821/api/v1/stats -H "Origin: app://obsidian.md"` → 204 + CORS headers ✅
-
-**Obsidian 插件 (`plugins/obsidian/`)**
-- `manifest.json`: id=`zhiyi-memory`, name=`织忆`, minAppVersion=`0.15.0`
-- `main.ts`: 注册 ZhiYiPlugin，3 个命令（记忆面板/图谱面板/搜索）+ 设置页
-- `src/api.ts`: fetch 封装，调用 Go API `/api/v1/*` 全部端点，API Key = `zhiy...`（截断）
-- `src/MemoryView.ts`: 侧边栏记忆列表，分页（每页20条），蒸馏队列警告
-- `src/GraphView.ts`: D3.js force-directed graph，ego-network 探索，节点拖拽/缩放
-- `src/SearchModal.ts`: 语义搜索模态框，debounce 300ms，Enter 选择第一条
-- `styles.css`: 全局样式，蒸馏警告高亮
-- `esbuild.config.mjs`: 构建 main.ts → main.js（minified）
-- 构建产物: `main.js` 22KB（已安装至 `~/.obsidian/plugins/zhiyi-memory/`）
-- `README.md`: 安装/使用文档
-
-**Makefile 新增目标**
-```makefile
-build-obsidian:     cd plugins/obsidian && node esbuild.config.mjs
-install-obsidian:   build-obsidian + cp to ~/.obsidian/plugins/zhiyi-memory/
-```
-
-**npm 修复**
-- `~/.local/bin/npm` 脚本指向错误路径 `/home/muc/.local/lib/node_modules/npm/bin/npm-cli.js`
-- 实际路径: `/home/muc/.local/lib/npm/bin/npm-cli.js`
-- 修复: `patch` 脚本中的路径后，npm --version 正常（10.9.7）
-
-### 验收标准 ✅
-- [x] CORS headers: `Access-Control-Allow-Origin: app://obsidian.md` ✅
-- [x] `make build-obsidian` → main.js 22KB ✅
-- [x] `make install-obsidian` → 文件复制到 `~/.obsidian/plugins/zhiyi-memory/` ✅
-- [x] Go API 1617 记忆正常 ✅
-
-### git commit
-```
-E5.1 Obsidian 插件: CORS中间件 + 记忆面板 + 图谱视图 + 搜索模态框
-abef38c
-```

cli-anything/cli_anything/zhiyi/README.md

@@ -1,62 +0,0 @@
-# ci-anything-zhiyi
-
-Agent-native CLI for **ZhiYi MemoryWeave** — 牧尘和小唯的记忆系统。
-
-让任何 AI Agent 直接在终端搜索记忆、探索知识图谱、查看系统统计。
-
-## 安装
-
-```bash
-# 克隆仓库后
-cd cli-anything-zhiyi
-pip install -e .
-
-# 带 REPL 支持
-pip install -e ".[repl]"
-```
-
-## 使用
-
-```bash
-# 系统诊断
-cli-anything-zhiyi health
-
-# 搜索记忆
-cli-anything-zhiyi search "架构决策"
-cli-anything-zhiyi search "小唯" --top-k 10 --mode hybrid
-
-# 查看统计
-cli-anything-zhiyi stats
-cli-anything-zhiyi stats --type graph
-
-# 图谱导航
-cli-anything-zhiyi graph navigate --entity "织忆" --hops 2
-
-# 记忆反馈
-cli-anything-zhiyi feedback --id mem_xxx --useful
-
-# 交互模式（默认）
-cli-anything-zhiyi repl
-
-# JSON 输出模式
-cli-anything-zhiyi search "织忆" --json
-```
-
-## 环境变量
-
-| 变量 | 默认值 | 说明 |
-|------|--------|------|
-| `ZHIYI_API_BASE` | `http://localhost:7821` | zhiyid 地址 |
-| `ZHIYI_API_KEY` | `zhiyi-dev-key-2026` | API 密钥 |
-
-## 命令
-
-| 命令 | 说明 |
-|------|------|
-| `health` | 4 组件健康检查 |
-| `search` | 记忆搜索 |
-| `stats` | 统计信息 |
-| `graph navigate` | 图谱导航 |
-| `graph cleanup` | 图谱清理 |
-| `feedback` | 记忆反馈 |
-| `repl` | REPL 交互模式 |

cli-anything/cli_anything/zhiyi/__init__.py

@@ -1,2 +0,0 @@
-#!/usr/bin/env python3
-"""cli-anything-zhiyi — Agent-native CLI for ZhiYi MemoryWeave."""

cli-anything/cli_anything/zhiyi/__main__.py

@@ -1,6 +0,0 @@
-#!/usr/bin/env python3
-"""python3 -m cli_anything.zhiyi — entry point for module invocation."""
-from cli_anything.zhiyi.zhiyi_cli import cli
-
-if __name__ == "__main__":
-    cli()

cli-anything/cli_anything/zhiyi/core/__init__.py

@@ -1 +0,0 @@
-"""ZhiYi MemoryWeave core module."""

cli-anything/cli_anything/zhiyi/core/client.py

@@ -1,150 +0,0 @@
-"""ZhiYi API client — wraps all zhiyid HTTP endpoints."""
-
-import json
-import urllib.request
-import urllib.error
-
-
-DEFAULT_BASE = "http://localhost:7821"
-def _default_key():
-    try:
-        for _l in open("/var/lib/memoryweave/.api-key"):
-            _s=_l.strip()
-            if _s and not _s.startswith("#") and not _s.startswith("legacy:"): return _s
-    except Exception: pass
-    return ""
-DEFAULT_KEY = _default_key()
-
-
-class ZhiYiClient:
-    """HTTP client for ZhiYi MemoryWeave API."""
-
-    def __init__(self, base: str | None = None, api_key: str | None = None):
-        self.base = (base or DEFAULT_BASE).rstrip("/")
-        self.api_key = api_key or DEFAULT_KEY
-
-    def _get(self, path: str) -> dict:
-        url = f"{self.base}{path}"
-        req = urllib.request.Request(url, headers={"X-API-Key": self.api_key})
-        try:
-            with urllib.request.urlopen(req, timeout=10) as resp:
-                return json.loads(resp.read().decode())
-        except urllib.error.HTTPError as e:
-            body = e.read().decode() if e.fp else "{}"
-            return {"error": f"HTTP {e.code}", "detail": json.loads(body) if body else {}}
-        except Exception as e:
-            return {"error": str(e)}
-
-    def _post(self, path: str, data: dict) -> dict:
-        url = f"{self.base}{path}"
-        body = json.dumps(data).encode()
-        req = urllib.request.Request(
-            url,
-            data=body,
-            headers={
-                "X-API-Key": self.api_key,
-                "Content-Type": "application/json",
-            },
-        )
-        try:
-            with urllib.request.urlopen(req, timeout=30) as resp:
-                return json.loads(resp.read().decode())
-        except urllib.error.HTTPError as e:
-            raw = e.read().decode() if e.fp else "{}"
-            return {"error": f"HTTP {e.code}", "detail": json.loads(raw) if raw else {}}
-        except Exception as e:
-            return {"error": str(e)}
-
-    # ---- Public API ----
-
-    def health(self) -> dict:
-        return self._get("/api/v1/health")
-
-    def stats(self) -> dict:
-        return self._get("/api/v1/stats")
-
-    def graph_stats(self) -> dict:
-        return self._get("/api/v1/graph/stats")
-
-    def cache_stats(self) -> dict:
-        return self._get("/api/v1/cache/stats")
-
-    def metrics(self) -> dict:
-        return self._get("/api/v1/metrics")
-
-    def search(self, query: str, top_k: int = 5, mode: str = "hybrid",
-               diversity: float = 0.3) -> dict:
-        return self._post("/api/v1/recall", {
-            "query": query,
-            "top_k": top_k,
-            "mode": mode,
-            "diversity": diversity,
-        })
-
-    def graph_navigate(self, entity: str, max_hops: int = 2) -> dict:
-        return self._post("/api/v1/graph/navigate", {
-            "entity": entity,
-            "max_hops": max_hops,
-        })
-
-    def feedback(self, memory_id: str, useful: bool, reason: str = "") -> dict:
-        return self._post("/api/v1/memory/feedback", {
-            "memory_id": memory_id,
-            "useful": useful,
-            "reason": reason,
-        })
-
-    def graph_feedback(self, edge_id: str, useful: bool) -> dict:
-        return self._post("/api/v1/graph/edge/feedback", {
-            "edge_id": edge_id,
-            "useful": useful,
-        })
-
-    def graph_cleanup(self) -> dict:
-        return self._post("/api/v1/graph/cleanup", {})
-
-    def diagnose(self) -> dict:
-        """Run full system diagnosis across all known services."""
-        results = {}
-
-        # zhiyid health
-        h = self.health()
-        results["zhiyid"] = {"status": "ok" if h.get("status") == "ok" else "fail", "detail": h}
-
-        # bge-embed
-        try:
-            req = urllib.request.Request("http://localhost:8000/health", method="GET")
-            with urllib.request.urlopen(req, timeout=3) as resp:
-                bge = json.loads(resp.read().decode())
-                results["bge-embed"] = {"status": "ok", "detail": bge}
-        except Exception as e:
-            results["bge-embed"] = {"status": "fail", "detail": str(e)}
-
-        # IPC socket
-        import os
-        sock = "/tmp/zhiyi-ipc.sock"
-        results["ipc-sidecar"] = {
-            "status": "ok" if os.path.exists(sock) else "fail",
-            "detail": f"socket {'found' if os.path.exists(sock) else 'missing'}: {sock}",
-        }
-
-        # Graph DB
-        g = self.graph_stats()
-        results["graph-db"] = {
-            "status": "ok" if g.get("node_count", 0) > 0 else "warn",
-            "detail": g,
-        }
-
-        # Memory backend
-        s = self.stats()
-        results["memory-backend"] = {
-            "status": "ok" if s.get("total_memories", 0) > 0 else "warn",
-            "detail": s,
-        }
-
-        results["overall"] = "ok" if all(
-            r.get("status") == "ok" for r in results.values()
-            if isinstance(r, dict) and "status" in r
-        ) else "degraded"
-
-        return results

cli-anything/cli_anything/zhiyi/skills/SKILL.md

@@ -1,76 +0,0 @@
----
-name: cli-anything-zhiyi
-description: Use when the user wants to directly query ZhiYi MemoryWeave — search memories, explore knowledge graph, check system health, or view statistics from the terminal.
----
-
-# CLI-Anything: ZhiYi MemoryWeave
-
-## Overview
-
-ZhiYi (织忆) is the memory system serving 小唯 A06's multi-agent ecosystem. It stores semantic memories (3600+) in LanceDB and manages a knowledge graph (7200+ nodes, 62000+ edges) for structured entity relationships.
-
-This CLI lets any AI agent **directly** interact with ZhiYi — search memories, navigate the knowledge graph, check system health, and view statistics — without going through the Hermes plugin layer.
-
-## Quick Start
-
-```bash
-# The CLI is pre-installed in the Hermes venv
-cli-anything-zhiyi --help
-
-# System health check (always start here)
-cli-anything-zhiyi health
-
-# Search memories
-cli-anything-zhiyi search "架构决策" --top-k 5 --mode hybrid
-
-# Graph exploration
-cli-anything-zhiyi graph navigate --entity "织忆" --hops 2
-
-# Statistics
-cli-anything-zhiyi stats
-
-# All commands support JSON output
-cli-anything-zhiyi search "小唯" --json
-```
-
-## Commands
-
-| Command | Description | Key Options |
-|---------|-------------|-------------|
-| `health` | Full system diagnosis (5 components) | — |
-| `search <query>` | Semantic/keword/hybrid memory search | `--top-k`, `--mode`, `--diversity` |
-| `stats` | Memory, graph, cache, and metrics | `--type` (all/memories/graph/cache/metrics) |
-| `graph navigate` | Knowledge graph traversal | `--entity`, `--hops` |
-| `graph cleanup` | Remove stale graph edges | — |
-| `feedback` | Memory relevance feedback | `--id`, `--useful/--not-useful` |
-| `repl` | Interactive REPL mode | — |
-
-## Search Modes
-
-- `hybrid` (default): 0.7 semantic + 0.3 BM25 — best balance
-- `semantic`: Pure semantic search via bge-m3 embeddings
-- `keyword`: BM25 keyword matching
-
-## Environment
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `ZHIYI_API_BASE` | `http://localhost:7821` | zhiyid API endpoint |
-| `ZHIYI_API_KEY` | `zhiyi-dev-key-2026` | API authentication key |
-
-## JSON Output
-
-All commands support machine-readable JSON output with `--json` flag. This is the preferred mode for agent consumption:
-
-```json
-{"results": [{"id": "mem_xxx", "content": "...", "score": 0.95}]}
-```
-
-## Usage Guidance for Agents
-
-1. **Start with `health`** to verify ZhiYi is running before attempting queries.
-2. **Use `stats`** to understand the system scale before deciding search depth.
-3. **Search uses `--json`** and parse `results[].content` for memory text and `results[].score` for relevance.
-4. **Graph navigate** returns paths, grouped_by_relation, and suggestions — parse `paths[].to` and `paths[].relation` for entity discovery.
-5. **Provide feedback** with `feedback --id <id> --useful` to improve future recall quality.
-6. **When uncertain about an entity name**, use `graph navigate --entity <partial-name>` and read the `suggestions` field to find the correct entity.

cli-anything/cli_anything/zhiyi/tests/TEST.md

@@ -1,23 +0,0 @@
-# Test Plan for cli-anything-zhiyi
-
-## Test Files
-- `test_core.py` — Unit tests for ZhiYiClient
-
-## Unit Test Plan
-
-### `client.py`
-| Function | Test case | Expected |
-|----------|-----------|----------|
-| `__init__` | Default params | base=localhost:7821, key=default |
-| `__init__` | Custom params | Uses provided values |
-| `health()` | Live endpoint | status=ok, service=zhiyid |
-| `stats()` | Live endpoint | total_memories > 0 |
-| `graph_stats()` | Live endpoint | node_count > 0, edge_count > 0 |
-| `metrics()` | Live endpoint | total_memories present |
-| `search()` | Live query | Returns results |
-| `search()` | All modes | hybrid, semantic, keyword all work |
-| `diagnose()` | Full check | All 5 components present |
-
-## Results
-- Tests: 9/9 passing
-- Coverage: Client unit tests only (no CLI subprocess tests in v0.1.0)

cli-anything/cli_anything/zhiyi/tests/test_core.py

@@ -1,87 +0,0 @@
-"""Tests for cli-anything-zhiyi core client."""
-import json
-import sys
-import os
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "..", ".."))
-
-from cli_anything.zhiyi.core.client import ZhiYiClient
-
-
-def test_client_init():
-    c = ZhiYiClient()
-    assert c.base == "http://localhost:7821"
-    assert c.api_key == "zhiyi-dev-key-2026"
-
-
-def test_client_custom():
-    c = ZhiYiClient(base="http://test:9999", api_key="test-key")
-    assert c.base == "http://test:9999"
-    assert c.api_key == "test-key"
-
-
-def test_health():
-    c = ZhiYiClient()
-    r = c.health()
-    assert r.get("status") == "ok"
-    assert r.get("service") == "zhiyid"
-
-
-def test_stats():
-    c = ZhiYiClient()
-    r = c.stats()
-    assert "total_memories" in r
-    assert r["total_memories"] > 0
-
-
-def test_graph_stats():
-    c = ZhiYiClient()
-    r = c.graph_stats()
-    assert isinstance(r, dict), f"Expected dict, got {type(r)}: {r}"
-    # Allow both shapes (some calls return node_count, others don't on timeout)
-    if "node_count" in r:
-        assert r["node_count"] >= 0
-        assert "edge_count" in r
-
-
-def test_metrics():
-    c = ZhiYiClient()
-    r = c.metrics()
-    assert "total_memories" in r
-
-
-def test_search():
-    c = ZhiYiClient()
-    r = c.search("小唯", top_k=3)
-    results = r.get("results", [])
-    assert len(results) > 0
-
-
-def test_search_modes():
-    c = ZhiYiClient()
-    for mode in ["hybrid", "semantic", "keyword"]:
-        r = c.search("织忆", top_k=2, mode=mode)
-        assert r.get("results") is not None or r.get("memories") is not None
-
-
-def test_diagnose():
-    c = ZhiYiClient()
-    r = c.diagnose()
-    assert "zhiyid" in r
-    assert "bge-embed" in r
-    assert "ipc-sidecar" in r
-    assert "graph-db" in r
-    assert "memory-backend" in r
-    assert r.get("overall") in ("ok", "degraded")
-
-
-if __name__ == "__main__":
-    test_client_init()
-    test_client_custom()
-    test_health()
-    test_stats()
-    test_graph_stats()
-    test_metrics()
-    test_search()
-    test_search_modes()
-    test_diagnose()
-    print(f"\n✅ All {9} tests passed!")

cli-anything/cli_anything/zhiyi/utils/__init__.py

@@ -1 +0,0 @@
-"""ZhiYi CLI utilities."""

cli-anything/cli_anything/zhiyi/zhiyi_cli.py

@@ -1,459 +0,0 @@
-#!/usr/bin/env python3
-"""cli-anything-zhiyi — Agent-native CLI for ZhiYi MemoryWeave.
-
-Usage:
-    # One-shot
-    cli-anything-zhiyi health
-    cli-anything-zhiyi search "小唯" --top-k 5 --mode hybrid
-    cli-anything-zhiyi stats
-    cli-anything-zhiyi graph navigate "织忆" --hops 2
-
-    # Interactive REPL (default)
-    cli-anything-zhiyi repl
-    cli-anything-zhiyi   # same as repl
-"""
-
-import json
-import sys
-import os
-import shlex
-import shutil
-import subprocess
-from pathlib import Path
-
-import click
-
-from cli_anything.zhiyi.core.client import ZhiYiClient
-
-
-# ---- Globals ----
-_json_output = False
-_client: ZhiYiClient | None = None
-
-
-def get_client() -> ZhiYiClient:
-    global _client
-    if _client is None:
-        base = os.environ.get("ZHIYI_API_BASE")
-        key = os.environ.get("ZHIYI_API_KEY")
-        _client = ZhiYiClient(base=base, api_key=key)
-    return _client
-
-
-def output(data, message: str = ""):
-    if _json_output:
-        click.echo(json.dumps(data, indent=2, ensure_ascii=False, default=str))
-    else:
-        if message:
-            click.echo(message)
-        if isinstance(data, dict):
-            for k, v in data.items():
-                if isinstance(v, (dict, list)):
-                    click.echo(f"  {k}: {json.dumps(v, ensure_ascii=False, default=str)}")
-                else:
-                    click.echo(f"  {k}: {v}")
-        elif isinstance(data, list):
-            for item in data:
-                click.echo(f"  • {str(item)[:200]}")
-        else:
-            click.echo(str(data))
-
-
-# ---- Shared options ----
-_common = [
-    click.option("--json", "json_flag", is_flag=True, help="Machine-readable JSON output"),
-]
-
-
-def common_options(f):
-    for opt in reversed(_common):
-        f = opt(f)
-    return f
-
-
-# ---- CLI group ----
-
-
-@click.group(invoke_without_command=True)
-@click.pass_context
-@common_options
-def cli(ctx, json_flag):
-    """ZhiYi MemoryWeave — Agent-native memory system CLI."""
-    global _json_output
-    _json_output = json_flag
-    if ctx.invoked_subcommand is None:
-        ctx.invoke(repl)
-
-
-# ---- health ----
-
-
-@cli.command()
-@common_options
-def health(json_flag):
-    """Check system health (zhiyid, bge-embed, IPC sidecar, graph DB)."""
-    global _json_output
-    _json_output = json_flag
-    result = get_client().diagnose()
-    if _json_output:
-        click.echo(json.dumps(result, indent=2, ensure_ascii=False))
-        return
-
-    click.echo("═══ 织忆系统诊断 ═══")
-    for component, info in result.items():
-        if component == "overall":
-            continue
-        status = info.get("status", "?")
-        icon = {"ok": "✅", "warn": "⚠️", "fail": "❌"}.get(status, "❓")
-        click.echo(f"  {icon} {component}: {status}")
-
-    overall = result.get("overall", "?")
-    icon = {"ok": "✅", "degraded": "⚠️", "fail": "❌"}.get(overall, "❓")
-    click.echo(f"\n  {icon} 整体状态: {overall}")
-
-
-# ---- search ----
-
-
-@cli.command()
-@click.argument("query")
-@click.option("--top-k", default=5, type=int, help="Number of results (default: 5)")
-@click.option("--mode", default="hybrid",
-              type=click.Choice(["hybrid", "semantic", "keyword"]),
-              help="Search mode (default: hybrid)")
-@click.option("--diversity", default=0.3, type=float, help="MMR diversity (0-1, default: 0.3)")
-@common_options
-def search(query, top_k, mode, diversity, json_flag):
-    """Search memories by query."""
-    global _json_output
-    _json_output = json_flag
-    result = get_client().search(query, top_k=top_k, mode=mode, diversity=diversity)
-
-    if _json_output:
-        click.echo(json.dumps(result, indent=2, ensure_ascii=False, default=str))
-        return
-
-    results = result.get("results", result.get("memories", []))
-    click.echo(f"🔍 搜索 \"{query}\" [{mode}, top_{top_k}, diversity={diversity}]")
-    click.echo(f"   找到 {len(results)} 条结果\n")
-    for i, r in enumerate(results, 1):
-        content = r.get("content", "")
-        score = r.get("score", 0)
-        mid = r.get("id", r.get("memory_id", ""))
-        # Truncate content for display
-        display = str(content)[:200].replace("\n", " ")
-        click.echo(f"  [{i}] (score={score:.3f}) {display}")
-        click.echo(f"       id: {mid}")
-        click.echo()
-
-
-# ---- stats ----
-
-
-@cli.command()
-@click.option("--type", "stat_type", default="all",
-              type=click.Choice(["all", "memories", "graph", "cache", "metrics"]),
-              help="Stat category (default: all)")
-@common_options
-def stats(stat_type, json_flag):
-    """Show memory/graph/cache/metrics statistics."""
-    global _json_output
-    _json_output = json_flag
-    c = get_client()
-
-    data = {}
-    if stat_type in ("all", "memories"):
-        data["memories"] = c.stats()
-    if stat_type in ("all", "graph"):
-        data["graph"] = c.graph_stats()
-    if stat_type in ("all", "cache"):
-        data["cache"] = c.cache_stats()
-    if stat_type in ("all", "metrics"):
-        data["metrics"] = c.metrics()
-
-    if _json_output:
-        click.echo(json.dumps(data, indent=2, ensure_ascii=False, default=str))
-        return
-
-    click.echo("═══ 织忆统计 ═══")
-
-    if "memories" in data:
-        s = data["memories"]
-        click.echo(f"\n📦 记忆后端: {s.get('backend', '?')}")
-        click.echo(f"   记忆: {s.get('total_memories', '?')} 条")
-        click.echo(f"   片段: {s.get('total_episodes', '?')} 条")
-        click.echo(f"   数据目录: {s.get('data_dir', '?')}")
-
-    if "graph" in data:
-        g = data["graph"]
-        click.echo(f"\n🕸️  图谱: {g.get('node_count', '?')} 节点 / {g.get('edge_count', '?')} 边")
-        click.echo(f"   密度: {g.get('density', '?'):.6f}")
-
-    if "cache" in data:
-        ca = data["cache"].get("graph_cache", {})
-        click.echo(f"\n⚡ 缓存: {ca.get('size', '?')}/{ca.get('max_size', '?')} | "
-                   f"命中: {ca.get('total_hits', '?')} 次 | TTL: {ca.get('ttl', '?')}")
-
-    if "metrics" in data:
-        m = data["metrics"]
-        click.echo(f"\n📊 自优化指标:")
-        click.echo(f"   召回命中率: {m.get('recall_hit_rate', '?'):.1%}")
-        click.echo(f"   召回有用率: {m.get('recall_usefulness_rate', '?'):.1%}")
-        click.echo(f"   记忆总数: {m.get('total_memories', '?')}")
-
-
-# ---- graph ----
-
-
-@cli.group()
-def graph():
-    """Graph operations."""
-    pass
-
-
-@graph.command("navigate")
-@click.option("--entity", "-e", required=True, help="Entity to navigate from")
-@click.option("--hops", "-n", default=2, type=int, help="Max hops (default: 2)")
-@common_options
-def graph_navigate(entity, hops, json_flag):
-    """Navigate the knowledge graph from an entity."""
-    global _json_output
-    _json_output = json_flag
-    result = get_client().graph_navigate(entity, max_hops=hops)
-
-    if _json_output:
-        click.echo(json.dumps(result, indent=2, ensure_ascii=False, default=str))
-        return
-
-    click.echo(f"🕸️  从 \"{entity}\" 出发，{hops} 跳")
-    paths = result.get("paths", [])
-    relation_count = result.get("relation_count", 0)
-    suggestions = result.get("suggestions", [])
-
-    click.echo(f"   找到 {len(paths)} 条路径, {relation_count} 种关系\n")
-
-    # Group by relation
-    grouped = result.get("grouped_by_relation", {})
-    if grouped:
-        for rel, edges in grouped.items():
-            click.echo(f"  [{rel}]")
-            for e in edges[:10]:
-                click.echo(f"    {e.get('from', '?')} → {e.get('to', '?')} (w={e.get('weight', 0):.3f})")
-            click.echo()
-
-    if suggestions:
-        click.echo(f"💡 建议继续探索:")
-        for s in suggestions[:10]:
-            click.echo(f"   • {s}")
-
-
-@graph.command("stats")
-@common_options
-def graph_stats_cmd(json_flag):
-    """Show graph statistics."""
-    global _json_output
-    _json_output = json_flag
-    result = get_client().graph_stats()
-    output(result)
-
-
-@graph.command("cleanup")
-@common_options
-def graph_cleanup(json_flag):
-    """Clean up stale graph edges."""
-    global _json_output
-    _json_output = json_flag
-    result = get_client().graph_cleanup()
-    output(result)
-
-
-# ---- feedback ----
-
-
-@cli.command()
-@click.option("--id", "memory_id", required=True, help="Memory ID to provide feedback on")
-@click.option("--useful/--not-useful", default=True, help="Whether this memory was useful")
-@click.option("--reason", default="", help="Optional reason (only for not-useful)")
-@common_options
-def feedback(memory_id, useful, reason, json_flag):
-    """Provide feedback on a memory."""
-    global _json_output
-    _json_output = json_flag
-    result = get_client().feedback(memory_id, useful=useful, reason=reason)
-    output(result, f"反馈已发送: {'✅ 有用' if useful else '❌ 无用'} → {memory_id}")
-
-
-# ---- repl ----
-
-
-@cli.command()
-@common_options
-def repl(json_flag):
-    """Interactive REPL mode."""
-    global _json_output
-    _json_output = json_flag
-    c = get_client()
-
-    # Try to use ReplSkin if available, fall back to simple REPL
-    try:
-        from cli_anything.zhiyi.utils.repl_skin import ReplSkin
-        skin = ReplSkin("zhiyi", version="0.1.0")
-        skin.print_banner()
-        _repl_with_skin(c, skin)
-    except ImportError:
-        _repl_simple(c)
-
-
-def _repl_simple(c: ZhiYiClient):
-    """Simple REPL fallback."""
-    click.echo("ZhiYi REPL — 输入 ? 查看帮助, quit 退出")
-    while True:
-        try:
-            line = click.prompt("zhiyi", prompt_suffix="> ").strip()
-        except (EOFError, KeyboardInterrupt):
-            click.echo("\n再见 👋")
-            break
-
-        if not line:
-            continue
-        if line in ("quit", "exit", "q"):
-            click.echo("再见 👋")
-            break
-        if line in ("?", "help"):
-            click.echo("""
-可用命令:
-  health                  — 系统诊断
-  search <query>          — 搜索记忆
-  stats                   — 查看统计
-  graph navigate <entity> — 图谱导航
-  feedback <id> <0|1>     — 记忆反馈
-  ? / help                — 帮助
-  quit / exit             — 退出
-""")
-            continue
-
-        parts = shlex.split(line)
-        cmd = parts[0]
-        args = parts[1:]
-
-        try:
-            if cmd == "health":
-                r = c.diagnose()
-                click.echo(json.dumps(r, indent=2, ensure_ascii=False))
-            elif cmd == "search":
-                query = " ".join(args) if args else click.prompt("query")
-                r = c.search(query)
-                for res in r.get("results", r.get("memories", [])):
-                    click.echo(f"  [{res.get('score', 0):.3f}] {str(res.get('content',''))[:150]}")
-            elif cmd == "stats":
-                click.echo(json.dumps(c.stats(), indent=2, ensure_ascii=False))
-                click.echo(json.dumps(c.graph_stats(), indent=2, ensure_ascii=False))
-            elif cmd == "graph" and args and args[0] == "navigate":
-                entity = args[1] if len(args) > 1 else click.prompt("entity")
-                r = c.graph_navigate(entity)
-                click.echo(json.dumps(r, indent=2, ensure_ascii=False)[:1000])
-            elif cmd == "feedback" and len(args) >= 2:
-                mid = args[0]
-                useful = args[1].lower() in ("1", "true", "yes", "y")
-                r = c.feedback(mid, useful=useful)
-                click.echo(f"反馈结果: {r}")
-            else:
-                click.echo(f"未知命令: {cmd}  (输入 ? 查看帮助)")
-        except Exception as e:
-            click.echo(f"错误: {e}")
-
-
-def _repl_with_skin(c: ZhiYiClient, skin):
-    """REPL with ReplSkin (prompt_toolkit)."""
-    from prompt_toolkit import PromptSession
-    from prompt_toolkit.history import FileHistory
-    import atexit
-
-    hist_path = os.path.expanduser("~/.zhiyi_history")
-    session = PromptSession(history=FileHistory(hist_path))
-
-    commands = {
-        "health": "系统诊断",
-        "search": "搜索记忆",
-        "stats": "查看统计",
-        "graph": "图谱操作 (navigate, stats, cleanup)",
-        "feedback": "记忆反馈",
-    }
-
-    skin.help(commands)
-
-    while True:
-        try:
-            line = skin.get_input(session)
-        except (EOFError, KeyboardInterrupt):
-            break
-        except Exception:
-            break
-
-        if not line:
-            continue
-        line = line.strip()
-        if line in ("quit", "exit", "q"):
-            break
-        if line in ("?", "help"):
-            skin.help(commands)
-            continue
-
-        parts = shlex.split(line)
-        cmd = parts[0]
-        args = parts[1:]
-
-        try:
-            if cmd == "health":
-                r = c.diagnose()
-                for comp, info in r.items():
-                    if comp == "overall":
-                        continue
-                    icon = {"ok": "✅", "warn": "⚠️", "fail": "❌"}.get(info.get("status", ""), "❓")
-                    skin.info(f"{icon} {comp}")
-            elif cmd == "search":
-                query = " ".join(args) if args else click.prompt("query")
-                r = c.search(query)
-                results = r.get("results", r.get("memories", []))
-                for res in results[:5]:
-                    score = res.get("score", 0)
-                    content = str(res.get("content", ""))[:200].replace("\n", " ")
-                    skin.status(f"[{score:.3f}]", content)
-            elif cmd == "stats":
-                s = c.stats()
-                g = c.graph_stats()
-                m = c.metrics()
-                skin.table(
-                    ["指标", "值"],
-                    [
-                        ["记忆数", str(s.get("total_memories", "?"))],
-                        ["图谱节点", str(g.get("node_count", "?"))],
-                        ["图谱边", str(g.get("edge_count", "?"))],
-                        ["召回命中率", f"{m.get('recall_hit_rate', '?'):.1%}"],
-                    ],
-                )
-            elif cmd == "graph" and args and args[0] == "navigate":
-                entity = args[1] if len(args) > 1 else click.prompt("entity")
-                r = c.graph_navigate(entity)
-                paths = r.get("paths", [])
-                skin.info(f"找到 {len(paths)} 条路径")
-                for p in paths[:5]:
-                    skin.status("→", f"{p.get('from', '?')} → {p.get('to', '?')} ({p.get('relation', '?')})")
-            elif cmd == "feedback" and len(args) >= 2:
-                mid = args[0]
-                useful = args[1].lower() in ("1", "true", "yes", "y")
-                c.feedback(mid, useful=useful)
-                skin.success("反馈已发送")
-            else:
-                skin.warning(f"未知命令: {cmd}")
-        except Exception as e:
-            skin.error(str(e))
-
-    skin.print_goodbye()
-
-
-# ---- Main ----
-
-
-if __name__ == "__main__":
-    cli()

cli-anything/setup.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-"""setup.py for cli-anything-zhiyi."""
-from pathlib import Path
-from setuptools import setup, find_namespace_packages
-
-ROOT = Path(__file__).parent
-README = ROOT / "cli_anything/zhiyi/README.md"
-
-long_description = README.read_text(encoding="utf-8") if README.exists() else "ZhiYi MemoryWeave CLI"
-
-setup(
-    name="cli-anything-zhiyi",
-    version="0.1.0",
-    description="Agent-native CLI for ZhiYi MemoryWeave — search, explore, and manage your memory system",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    author="小唯 A06",
-    packages=find_namespace_packages(include=("cli_anything.*",)),
-    python_requires=">=3.10",
-    install_requires=[
-        "click>=8.1",
-    ],
-    extras_require={
-        "dev": ["pytest>=7"],
-        "repl": ["prompt-toolkit>=3.0"],
-    },
-    entry_points={
-        "console_scripts": [
-            "cli-anything-zhiyi=cli_anything.zhiyi.zhiyi_cli:cli",
-        ],
-    },
-    package_data={
-        "cli_anything.zhiyi": ["skills/*.md"],
-    },
-    include_package_data=True,
-    zip_safe=False,
-    keywords=["cli", "zhiyi", "memory", "knowledge-graph", "ai"],
-    classifiers=[
-        "Development Status :: 4 - Beta",
-        "Intended Audience :: Developers",
-        "Topic :: Scientific/Engineering :: Artificial Intelligence",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python :: 3",
-    ],
-)

deploy/systemd/bge-embed.service

@@ -1,17 +0,0 @@
-[Unit]
-Description=MemoryWeave BGE-M3 ONNX Embed Server
-After=network.target
-
-[Service]
-Type=simple
-Environment="BGE_MODEL_PATH=/home/muc/models/bge-m3/onnx"
-Environment="BGE_PORT=8000"
-ExecStartPre=/bin/bash -c 'if [ ! -f /home/muc/.hermes/scripts/bge_embed_server.py ]; then cp /tmp/memoryweave/deploy/bge_embed_server.py /home/muc/.hermes/scripts/ 2>/dev/null || true; fi'
-ExecStart=/home/muc/.hermes/hermes-agent/.venv/bin/python3 /home/muc/.hermes/scripts/bge_embed_server.py
-Restart=always
-RestartSec=5
-StandardOutput=append:/tmp/bge_embed.log
-StandardError=append:/tmp/bge_embed.log
-
-[Install]
-WantedBy=default.target

deploy/systemd/zhiyi-consolidate.service

@@ -1,16 +0,0 @@
-[Unit]
-Description=MemoryWeave Rust IPC Sidecar (zhiyi-consolidate)
-After=network.target
-
-[Service]
-Type=simple
-Environment="RUST_LOG=info"
-ExecStartPre=/bin/bash -c 'if [ ! -f /home/muc/bin/zhiyi-consolidate ]; then cp /tmp/memoryweave/rust/target/release/zhiyi-consolidate /home/muc/bin/ 2>/dev/null || true; fi'
-ExecStart=/home/muc/bin/zhiyi-consolidate --mode socket --socket /tmp/zhiyi-ipc.sock --data-dir /var/lib/memoryweave
-Restart=always
-RestartSec=5
-StandardOutput=append:/tmp/zhiyi-sidecar.log
-StandardError=append:/tmp/zhiyi-sidecar.log
-
-[Install]
-WantedBy=default.target

deploy/systemd/zhiyid.service

@@ -1,18 +0,0 @@
-[Unit]
-Description=ZhiYi MemoryWeave (织忆) — Go Daemon
-Documentation=http://192.168.123.11:3000/xiaoxue_admin/memoryweave
-After=network.target zhiyi-consolidate.service bge-embed.service
-Wants=zhiyi-consolidate.service bge-embed.service
-
-[Service]
-Type=simple
-ExecStartPre=/bin/mkdir -p /var/lib/memoryweave /home/muc/.logs
-ExecStart=/home/muc/bin/zhiyid-new
-Restart=always
-RestartSec=5
-MemoryMax=2G
-CPUQuota=200%
-Environment=STORAGE_BACKEND=lancedb
-
-[Install]
-WantedBy=default.target

deploy/zhiyi-backup.sh

@@ -16,7 +16,7 @@ mkdir -p "$BACKUP_DIR"
 # 1. 调用 API 触发备份
 echo "[backup] Triggering admin/backup API..."
 curl -s -X POST http://localhost:7821/api/v1/admin/backup \
-  -H "X-API-Key: $ZHIYI_KEY" > /dev/null 2>&1 || true
+  -H "X-API-Key: zhiyi-dev-key-2026" > /dev/null 2>&1 || true
 
 # 2. LanceDB checkpoint + SQLite + Redis
 echo "[backup] Creating archive..."

deploy/zhiyi-consolidate.service

@@ -1,32 +1,13 @@
-# 织忆 MemoryWeave Rust IPC Sidecar (zhiyi-consolidate) — 用户级 systemd unit 单一真相源（t_f57b8bbf 对齐）
-# 实际安装落点：~/.config/systemd/user/zhiyi-consolidate.service
-# 运行事实（勿与过期全局版混淆）：
-#   - 二进制    /home/muc/bin/zhiyi-consolidate（非 /usr/local/bin）
-#   - 参数      --mode socket（非旧 --socket）
-#   - 数据目录  /var/lib/memoryweave（非 .../lancedb 子目录）
-#   - systemd   用户级；sidecar 是 simple 常驻（非旧的 oneshot+timer 设计）
-#   - 生命周期  20-partof-zhiyid.conf drop-in 加 PartOf=zhiyid.service ⇒ 重启 zhiyid 时 sidecar 跟着重启
-#   - ExecStartPre=-rm -f /tmp/zhiyi-ipc.sock 清理残留 socket（防 EADDRINUSE）
-# 其它 drop-in：10-malloc.conf / limit.conf（见 ~/.config/systemd/user/zhiyi-consolidate.service.d/）
-
 [Unit]
-Description=MemoryWeave Rust IPC Sidecar (zhiyi-consolidate)
+Description=ZhiYi Consolidation Engine (Rust LanceDB)
 After=network.target
-PartOf=zhiyid.service
 
 [Service]
 Type=simple
-Environment="RUST_LOG=info"
-ExecStartPre=/bin/bash -c 'if [ ! -f /home/muc/bin/zhiyi-consolidate ]; then cp /tmp/memoryweave/rust/target/release/zhiyi-consolidate /home/muc/bin/ 2>/dev/null || true; fi'
-ExecStartPre=-rm -f /tmp/zhiyi-ipc.sock
-ExecStart=/home/muc/bin/zhiyi-consolidate --mode socket --socket /tmp/zhiyi-ipc.sock --data-dir /var/lib/memoryweave
+User=muc
+ExecStart=/usr/local/bin/zhiyi-consolidate --socket /tmp/zhiyi-ipc.sock --data-dir /var/lib/memoryweave/lancedb
 Restart=always
 RestartSec=5
-# 2026-09-23：原为 append:/tmp/zhiyi-sidecar.log（无轮转 → 涨到 63M/95万行）
-# 改为 journald，由 systemd 统一管理与限额（journalctl -u zhiyi-consolidate）
-StandardOutput=journal
-StandardError=journal
-SyslogIdentifier=zhiyi-consolidate
 
 [Install]
-WantedBy=default.target
+WantedBy=multi-user.target

deploy/zhiyid.service

@@ -1,44 +1,30 @@
-# 织忆 MemoryWeave Go Daemon — 用户级 systemd unit 单一真相源（t_f57b8bbf 对齐）
-# 实际安装落点：~/.config/systemd/user/zhiyid.service（本文件是仓库内的脱敏母版，安装/比对用）
-#
-# ⚠️ 脱敏说明：仓库历史里曾含 3 个明文密钥（API_KEY / MOLIFANG_API_KEY / LLM_API_KEY），
-#    已随 git 推到 Gitea origin/main。本文件为脱敏版，不携带任何真实密钥；
-#    真实密钥/端点由运行环境注入。密钥清理属独立专项（本卡不碰 git 历史）。
-#
-# 运行事实（勿与过期全局版混淆）：
-#   - 二进制    /home/muc/bin/zhiyid-new（install 装，非 /usr/local/bin）
-#   - systemd   用户级 ~/.config/systemd/user/（非 /etc/systemd/system 全局）
-#   - 数据目录  /var/lib/memoryweave
-#   - sidecar   zhiyi-consolidate 是独立 unit，本 unit 用 Wants=（单向拉起）+ 其侧 PartOf= 回连重启
-# 构建产物  go/cmd/zhiyid/zhiyid（gitignored）→ install 到 /home/muc/bin/zhiyid-new
-
 [Unit]
-Description=ZhiYi MemoryWeave (织忆) — Go Daemon
-Documentation=http://192.168.123.11:3000/xiaoxue_admin/memoryweave
-After=network.target zhiyi-consolidate.service bge-proxy.service
-Wants=zhiyi-consolidate.service bge-proxy.service
-# 2026-09-05 按需化: embedding 走 8000 bge-proxy(远端104优先→本地8001按需拉起)
-# 原 Wants bge-embed.service 已移除（本地 fallback 不常驻）
+Description=ZhiYi MemoryWeave Go Service (织忆)
+After=network.target redis-server.service
+Wants=redis-server.service
 
 [Service]
 Type=simple
-ExecStartPre=/bin/mkdir -p /var/lib/memoryweave /home/muc/.logs
-ExecStart=/home/muc/bin/zhiyid-new
+User=muc
+WorkingDirectory=/home/muc/projects/memoryweave/go
+Environment=PORT=7821
+Environment=STORAGE_BACKEND=lancedb
+Environment=SQLITE_PATH=/var/lib/memoryweave/memoryweave.db
+Environment=API_KEY=zhiyi-dev-key-2026
+Environment=VLLM_ENDPOINT=https://ai.gitee.com/v1/embeddings
+Environment=MOLIFANG_API_KEY=3TSVVXRFFECE4TISXHGE1VXDAXBIPAP6O1VPJK18
+Environment=LLM_ENDPOINT=http://127.0.0.1:3000/v1/chat/completions
+Environment=LLM_MODEL=qwen/qwen3.5-122b-a10b
+Environment=LLM_API_KEY=sk-0ExNiLblJvIWBDpkS50fwOBw4MmqLyKdHJK5iQtlw9dOMWBP
+Environment=RERANK_ENDPOINT=https://ai.gitee.com/v1
+Environment=GRAPH_PATH=/var/lib/memoryweave/graph.db
+ExecStartPre=/bin/mkdir -p /var/lib/memoryweave
+ExecStart=/usr/local/bin/zhiyid
 Restart=always
 RestartSec=5
-MemoryMax=2G
+
+MemoryMax=512M
 CPUQuota=200%
-Environment=STORAGE_BACKEND=lancedb
-# 2026-09-14 distill 改走队列代理 8081（fail fast，避免打爆单槽）
-Environment=LLM_ENDPOINT=http://127.0.0.1:8081/v1/chat/completions
-Environment=LLM_MODEL=local/minicpm5-2b
-Environment=LLM_API_KEY=local-key
-# 2026-09-22 restore rerank: use local cosine reranker via bge-embed service on port 8001
-Environment=RERANK_ENDPOINT=http://127.0.0.1:8001
-# 以下按需 drop-in（~/.config/systemd/user/zhiyid.service.d/）：
-#   20-obsidian-vault.conf  → OBSIDIAN_VAULT=/home/muc/mc
-#   bind-lan-vpn.conf       → ZHIYI_BIND=0.0.0.0（ufw 收窄 LAN/VPN 两网段）
-#   provenance-observe.conf → ZHIYI_COMMIT_PROVENANCE_OBSERVE=1
 
 [Install]
-WantedBy=default.target
+WantedBy=multi-user.target

docker-compose.yml

@@ -1,95 +0,0 @@
-# 织忆 MemoryWeave — Docker Compose 一键部署
-# 用法: docker compose up -d
-
-services:
-  # ── 核心服务 ──────────────────────────────────────
-  zhiyid:
-    image: zhiyid:latest
-    container_name: zhiyid
-    restart: unless-stopped
-    ports:
-      - "7821:7821"
-    environment:
-      PORT: 7821
-      STORAGE_BACKEND: lancedb
-      SQLITE_PATH: /var/lib/memoryweave/memoryweave.db
-      GRAPH_PATH: /var/lib/memoryweave/graph.db
-      LANCEDB_SOCKET: /tmp/zhiyi-ipc.sock
-      API_KEY: ${API_KEY:-zhiyi-dev-key-2026}
-      VLLM_ENDPOINT: ${VLLM_ENDPOINT:-http://bge-m3:8000/v1/embeddings}
-      RERANK_ENDPOINT: ${RERANK_ENDPOINT:-}
-      LLM_ENDPOINT: ${LLM_ENDPOINT:-}
-      LLM_MODEL: ${LLM_MODEL:-}
-      LLM_API_KEY: ${LLM_API_KEY:-}
-      MOLIFANG_API_KEY: ${MOLIFANG_API_KEY:-}
-      STATIC_DIR: /app/static
-      ZHIYI_WEB_UI_ROOT: /app/web-ui/index.html
-    volumes:
-      - zhiyi-data:/var/lib/memoryweave
-      - zhiyi-logs:/home/appuser/.logs
-      - ./web-ui:/app/web-ui:ro
-      - ./static:/app/static:ro
-    healthcheck:
-      test: ["CMD", "curl", "-sf", "http://localhost:7821/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 10s
-    networks:
-      - zhiyi-net
-
-  # ── Redis（可选，事件流用）──────────────────────────
-  redis:
-    image: redis:7-alpine
-    container_name: zhiyi-redis
-    restart: unless-stopped
-    command: redis-server --appendonly yes --maxmemory 256mb
-    volumes:
-      - zhiyi-redis:/data
-    networks:
-      - zhiyi-net
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-
-  # ── BGE-M3 Embedding 模型（可选）───────────────────
-  # 如已有外部 embedding 服务，可注释此节
-  bge-m3:
-    image: ghcr.io/ggerganov/llama.cpp:latest
-    container_name: zhiyi-bge-m3
-    restart: unless-stopped
-    entrypoint: []
-    command: >
-      python3 -m http.server 8000 --directory /models
-    # 如需真正加载 BGE-M3 模型，取消注释下面的 volumes
-    # 并将 bge-m3 模型文件放到 ./models/bge-m3/onnx/
-    # volumes:
-    #   - ./models:/models:ro
-    ports:
-      - "8000:8000"
-    networks:
-      - zhiyi-net
-    healthcheck:
-      test: ["CMD", "curl", "-sf", "http://localhost:8000/v1/models"]
-      interval: 60s
-      timeout: 10s
-      retries: 3
-      start_period: 30s
-    deploy:
-      resources:
-        limits:
-          memory: 4G
-
-networks:
-  zhiyi-net:
-    driver: bridge
-
-volumes:
-  zhiyi-data:
-    driver: local
-  zhiyi-logs:
-    driver: local
-  zhiyi-redis:
-    driver: local

docs/07-Wiki-index/织忆同步/data_structure.md

@@ -1,28 +0,0 @@
-# 织忆同步 — 索引
-
-## 用途
-织忆（MemoryWeave）从 Obsidian 同步而来的运行时笔记库。这些文件是织忆系统在运行过程中自动记录的操作日志、执行快照、CLI 命令输出、系统状态报告、实验记录和配置调优备忘。共 **1039 个文件**，均为 .md 格式。
-
-## 文件类别
-
-| 类别 | 约计 | 说明 |
-|------|------|------|
-| 织忆（Zhiyi）核心 | 150+ | `zhiyi-*`、`zhiyid` 相关 — 服务启停、配置、CLI 命令、consolidation、push、entity extraction、graph 输出等 |
-| Hermes / OpenClaw | 80+ | Hermes 网关、Agent、Gateway 配置、providers、cron 响应、memory recall 日志等 |
-| ComfyUI | 60+ | ComfyUI 安装、环境、备份、端口、运行日志、master 包等 |
-| System / OS | 80+ | systemctl、mkfs.ext4、磁盘空间、home 目录、Deepin、WSL、Arch、sudo 操作、符号链接等 |
-| 数据库与存储 | 70+ | LanceDB 配置/类别/双写、SQLite PRAGMA/WAL/backup、A_LiteDB 等 |
-| LLM / AI 服务 | 70+ | LLM 端点、vLLM、Ollama、embedder、MiniMax、API key、API 调用等 |
-| Go 开发 | 50+ | Go build、ReportJSON、Rust sidecar、consolidation pipeline、dual-master 架构等 |
-| Recall 与 Memory | 40+ | recall hit rate、usefulness rate、category、passive recall、flush、OnDistillComplete 等 |
-| 网络与远程 | 40+ | Tailscale、SSH、curl 请求、Server（Windows/Linux）、端口、derp 节点等 |
-| 实验记录（E 系列） | 30+ | E1 BFS、E3 em、E5_1 Obsidian 同步、E5_3 Web UI、UI 迭代记录等 |
-| Windows | 25+ | Windows 端 server、zhiyid、taskkill、setx、Unix socket、PID 等 |
-| Obsidian | 20+ | Obsidian 同步、vault 路径、CORS、PID、安装记录等 |
-| 其他 | 200+ | 测试内容、commit 记录、README、日期快照、按内容命名的零散笔记等 |
-
-## 使用提示
-- 文件命名源于 Obsidian 同步时的标题，含较多中英文混排和截断 —— 建议以目录浏览 + 关键词搜索方式查找
-- 同一条操作（如 E5 系列）可能分散在多个文件中，可按主题前缀（E1、E5、zhiyi、ComfyUI 等）检索
-- 本目录为织忆运行日志的持久化存档，承载了大量调试和调优历史，是排查问题和追溯决策的重要来源
-- 部分文件含重复/近似内容（如多次 recall、多次 commit 记录），需自行去重参考

docs/07-Wiki-index/织忆图谱/data_structure.md

@@ -1,28 +0,0 @@
-# 织忆图谱 — 索引
-
-## 用途
-织忆（MemoryWeave）知识图谱的节点记录库。存储织忆系统中各类概念节点、实体定义、属性标记、关系链接和状态快照，是织忆知识网络的基础事实层。共 **299 个文件**，均为 .md 格式。
-
-## 文件类别
-
-| 类别 | 约计 | 说明 |
-|------|------|------|
-| 硬件与资源 | 30+ | CPU、RAM、VRAM、GPU（RTX3050、MX450、GA107M）、磁盘（GB/GiB/MB）、显存需求等 |
-| 工具与框架 | 25+ | Hermes、OpenClaw、ComfyUI、LanceDB、Ollama、Tailscale、vLLM 等 |
-| 织忆内核概念 | 20+ | 记忆迁移、外部记忆、自有记忆、注入机制、异步写入队列、双写、双删、一致性检查、验证回忆等 |
-| 项目规划（P 系列） | 15+ | P0-P6 迭代计划 — 数据分离、二进制清理、旧版归档、文档清理、日志统一、Hermes 整理等 |
-| 操作与状态 | 40+ | 状态标记（活跃/正常/已修复/不可达/残留）、操作指令（创建/删/更新/生成/配置/安装/升级/缓存等） |
-| 配置与设置 | 20+ | Settings、Prefs、API、端口、--auth-key、ipv6os、icmpv4、环境变量等 |
-| 网页/UI 相关 | 10+ | Web UI、POST、React、curl、登录、客户端等 |
-| 启动/运行 | 10+ | 一句话启动、本地启动、服务拓扑、执行顺序、断点续跑等 |
-| 网络 | 10+ | Tailscale 配置、derp 节点、SSH、API 端点、unix socket 等 |
-| 文本生成/SD | 10+ | SD、SDXL、Flux、n_xl、n_realistic、n_majicmix 等模型相关 |
-| 日志与清理 | 10+ | 日志散乱、旧日志、日志统一、冗余二进制、文档清理、旧版归档等 |
-| 其他实体 | 100+ | 短命名概念节点（单字/双字标题如"是""和""行""基本""系统""工具"等） |
-
-## 使用提示
-- 每个文件对应一个织忆图谱节点，文件名即为节点名称（部分为单字/短语标题）
-- 图谱节点间通过内部链接相互关联，`AGENTS_md.md` 和 `AGENTS_md_1910.md` 等文件为 agent 指南
-- `_织忆图谱索引.md` 为图谱顶层导航文件
-- P 系列（P0-P6）是织忆系统迭代的五阶段规划，建议优先关注
-- 大量短命名节点（单字标题如"的""是""到""行""看"）是织忆自动生成的片段节点，可作为图谱细节线索但内容可能不完整

docs/07-Wiki-index/经证同步/data_structure.md

@@ -1,23 +0,0 @@
-# 经证同步 — 索引
-
-## 用途
-经证（JingZheng）模块的同步记录和运行凭证存档。存储经证系统在运行过程中产生的证据快照、API 调试记录、性能指标、配置备忘和测试结果。共 **29 个文件**，均为 .md 格式。
-
-## 文件类别
-
-| 类别 | 文件数 | 说明 |
-|------|--------|------|
-| API 与端点 | 5 | `_video endpoint`、`v1_1`、`v1_1_0` 相关调试记录；`https://apihub.ag`、`http://localhost` 端点验证 |
-| 性能与指标 | 4 | `total_memories: 1239`、`recall_usefulness_rate`、`recall_hit_rate: 93%`、`1_5_2GB` 等指标快照 |
-| G8 备份恢复 | 3 | `G8 Restore_ListBackups`、G8 相关操作日志、`g8g9` 相关 |
-| E 系列实验 | 4 | `E1 BFS`（3 个文件，含不同执行细节）、`E5_1 Obsidian` 同步记录 |
-| 织忆内部组件 | 4 | `Forgetter` 遗忘器调试、`Go ReportJSON`、`cron-progress` 集成 |
-| 数据库/存储 | 2 | `PRAGMA journal_mode_WAL` SQLite 优化、`CORS` 配置 |
-| 实体提取 | 2 | `Chinese entity extraction` 中文实体提取实验、`unused import` 清理 |
-| 其他 | 5 | `2026-05-30` 日期快照、rollback 记录、LLM 调用测试、episodes 记录、其他杂项 |
-
-## 使用提示
-- 本目录含经证系统运行期间的性能基准数据（recall hit rate 93%、total memories 1239 等），可作为评估指标参考
-- E1 BFS 相关文件（含不同变体）记录了经证系统的广度优先搜索实现试探
-- Forgetter 遗忘器文件记录了织忆记忆衰减/清理机制的调优过程
-- 文件数较少（29 个），可按主题前缀直接浏览全部内容

docs/BFS_GRAPH_EXPANSION_DESIGN.md

@@ -1,447 +0,0 @@
-# E1 图谱导航 BFS 扩展调研与设计方案
-
-> 状态：调研完成，方案初稿
-> 日期：2026-06-02
-> 负责人：Hermes 子任务
-
----
-
-## 1. 背景与现状分析
-
-### 1.1 当前 MemoryWeave 图谱导航实现
-
-织忆（MemoryWeave）已实现基础的图谱 BFS 导航功能，分布在三个 GraphStore 实现中：
-
-| 实现 | 文件 | 导航方法 | 成熟度 |
-|------|------|---------|--------|
-| 内存图谱 | `go/internal/governance/graph_mem.go` | 单源 BFS + 伪双向 BFS | 测试用 |
-| SQLite 图谱 | `go/internal/governance/graph_sqlite.go` | 单源 BFS + 真正双向 BFS | 生产级 |
-| 文件图谱 | `go/internal/governance/graph_file.go` | 基础导航 | 未细看 |
-
-#### 1.1.1 SQLite 实现（生产级）
-
-**单源 BFS** (`Navigate`):
-- 标准队列式 BFS，按跳数层序扩展
-- 逐跳 SQL 查询（`SELECT ... WHERE source = ?`）
-- 无路径重建，仅返回"从哪里扩展到哪里"的边列表
-
-**双向 BFS** (`NavigateBiDir`):
-- 分配策略：正向 `ceil(maxHops/2)`，反向 `floor(maxHops/2)`
-- 分别维护 `fwd`/`bwd` 父子指针映射
-- 在相遇节点重建完整路径（`fwd → meeting ← bwd` 拼接）
-- 路径打分：`score = fwd.pathProd × bwd.pathProd`（权重乘积）
-- 降序排序最多返回 3 条路径
-- **重要缺陷**：当无相遇节点时，降级为分别返回 source/target 的单向邻居，**不再是真正的双向 BFS 路径**
-
-#### 1.1.2 内存实现（测试用）
-
-```go
-// graph_mem.go 第 161-168 行
-func (g *InMemoryGraph) NavigateBiDir(source, target string, ...) ([]map[string]interface{}, error) {
-    if target == "" || target == source {
-        return g.Navigate(source, maxHops, namespace)
-    }
-    paths, err := g.Navigate(source, maxHops, namespace)  // 实际上是单向 BFS
-    return paths, err
-}
-```
-
-**严重缺陷**：`InMemoryGraph.NavigateBiDir` 直接委托给 `Navigate`，完全没有双向搜索逻辑，是伪实现。
-
-#### 1.1.3 Recall 管线集成（`storage/recall.go`）
-
-Recall 完整链路（Design §2.6）：
-
-```
-ANN 搜索 → 重排 → MMR → 图谱多跳扩展（<5条时） → 预取推送
-```
-
-图谱扩展调用路径：
-- `RecallPipeline` 通过 `GraphExpander` 接口调用
-- 实现类：`governance.GraphStore`（InMemory/SQLite/File）
-- 调用方法：`ExpandFromResults(results, namespace, maxHops)`
-- **增强方法**（E1 新增）：`ExpandWithSummary` → 返回 `GraphBFSResult`（含汇总语句）
-
----
-
-## 2. 参考项目调研
-
-### 2.1 Graphiti（Fixie AI）— Agent 时序记忆图谱
-
-**仓库**：`fixie-ai/graphiti`（开源）
-**描述**：为 LLM Agent 构建时序知识图谱，支持多跳推理
-
-**核心设计**：
-- **图结构**：基于 Neo4j，节点含 `fact` 和 `entity` 两种类型，边带时间戳
-- **多跳遍历**：在 Neo4j 上执行 Cypher 查询实现 BFS/DFS，支持跳数限制和关系类型过滤
-- **检索阶段**：结合向量相似度（pgvector）和图结构——先用向量找到候选节点，再用 BFS 扩展相关节点
-- **路径重建**：记录 parent 指针，BFS 完成后从目标节点回溯重建完整路径
-- **打分函数**：综合路径长度、边权重和时间衰减
-
-**关键 API**：
-```
-# Cypher 风格的多跳查询
-MATCH (a:Entity {name: "X"})-[:REL*1..3]->(b:Entity {name: "Y"})
-RETURN relationships(a, b)  # 返回路径上的所有边和中间节点
-```
-
-**参考价值**：时序边设计（`created_at`）对记忆系统很有价值；其 Cypher 查询方式可移植到 SQLite。
-
----
-
-### 2.2 Mem0（mem0ai/mem0）— 分层记忆系统
-
-**仓库**：`mem0ai/mem0`（开源，49.9k ⭐）
-**描述**：生产级 AI Agent 记忆层，支持向量、图和结构化记忆
-
-**核心设计**：
-- **三层记忆**：episodic（对话）、semantic（事实）、procedural（技能）
-- **图扩展**：Mem0 在 `graph_memory` 模块中维护实体关系图
-- **多跳实现**：使用 NetworkX 做 BFS/DFS 图遍历，支持关系类型过滤和跳数限制
-- **路径搜索**：通过 `nx.shortest_path()` 或 `nx.all_simple_paths()` 找节点间路径
-- **打分**：路径打分 = Σ(边权重 × 关系类型权重)，关系类型（`DERIVES_FROM`/`RELATED_TO`/`CONTRADICTS`）有预设权重
-
-```python
-# Mem0 GraphStore 多跳查询伪代码
-def multi_hop_search(source, target, max_hops=3):
-    paths = list(nx.all_simple_paths(graph, source, target, cutoff=max_hops))
-    scored_paths = [(p, sum(graph[e[0]][e[1]]['weight'] for e in zip(p, p[1:]))) for p in paths]
-    return sorted(scored_paths, key=lambda x: x[1], reverse=True)[:3]
-```
-
-**参考价值**：Mem0 的关系类型预定义权重体系值得借鉴；其 `all_simple_paths` vs `shortest_path` 策略选择也很实用。
-
----
-
-### 2.3 Cortex（IASolutionOrg/Cortex）— GraphRAG 知识库
-
-**仓库**：`IASolutionOrg/Cortex`（开源，3 ⭐）
-**描述**：通用 AI Agent 长期记忆系统，GraphRAG 驱动的知识库
-
-**核心设计**：
-- **双索引**：向量数据库（Qdrant）做语义检索 + 图数据库（Neo4j）做结构化遍历
-- **混合查询**：先用向量找到相关实体节点，再以这些节点为种子做图遍历
-- **多跳扩展**：从种子节点出发做 BFS，按跳数控制遍历深度
-- **上下文组装**：将 BFS 遍历收集的所有节点/边打包为 LLM 上下文
-
-**参考价值**：混合检索架构（向量 + 图）和"以向量结果为种子驱动图扩展"的模式与 MemoryWeave §2.6 设计高度一致。
-
----
-
-### 2.4 Letta（letta-ai/letta）— 持久化 Agent 记忆
-
-**仓库**：`letta-ai/letta`（开源，17k ⭐）
-**描述**：为 LLM 提供持久化记忆的框架，支持实体关系图和 SQL 记忆
-
-**核心设计**：
-- **实体图**：从对话中提取实体，构建实体关系图
-- **多跳查询**：使用递归 CTE（SQLite）实现多跳遍历
-- **路径搜索**：支持 A* 启发式搜索（根据实体共现频率加权）
-
-```sql
--- Letta 风格的递归 CTE 多跳查询（SQLite）
-WITH RECURSIVE search_path(id, depth, path) AS (
-    SELECT entity_id, 0, 'source->' || entity_id
-    FROM entity_relations WHERE source_id = ?
-    UNION ALL
-    SELECT r.target_id, sp.depth + 1, sp.path || '->' || r.target_id
-    FROM entity_relations r, search_path sp
-    WHERE r.source_id = sp.id AND sp.depth < ?
-)
-SELECT * FROM search_path WHERE id = ?;
-```
-
-**参考价值**：递归 CTE 是 SQLite 原生支持的高效多跳实现，可替代当前应用层 BFS。
-
----
-
-### 2.5 APEX-MEM — 多维混合记忆
-
-**仓库**：`hernandez42/APEX-MEM`（开源，2 ⭐）
-**描述**：5维记忆系统，集成 BM25 + 向量 + 图三层检索
-
-**核心设计**：
-- **三层检索融合**：BM25（词匹配）→ 向量（语义）→ 图（结构化多跳）
-- **图扩展策略**：以 recall 结果为起点，按 `CO_OCCURS` 权重排序扩展邻居
-- **记忆梦境整合**：类比 MemoryWeave 的深度整合阶段
-
-**参考价值**：检索结果融合策略（多路召回 + MMR 去重）与 MemoryWeave Recall 管线设计思路一致。
-
----
-
-### 2.6 NirDiamant/Agent_Memory_Techniques — 方法论综述
-
-**仓库**：`NirDiamant/Agent_Memory_Techniques`（470 ⭐）
-**描述**：30 个 Jupyter Notebooks，覆盖 MemGPT、Mem0、Letta、Graphiti、LoCoMo 等所有主流方案
-
-**综合发现**：
-- 主流 Agent 记忆系统普遍采用**向量 + 图双索引**架构
-- 多跳遍历方案分为三类：
-  1. **Neo4j + Cypher**（Graphiti、Mem0 生产版）
-  2. **NetworkX + DFS/BFS**（Mem0 轻量版、研究用途）
-  3. **SQLite 递归 CTE**（Letta、本地优先方案）
-- 所有系统都面临共同挑战：路径爆炸、循环检测、权重归一化
-
----
-
-## 3. 现状问题分析
-
-### 3.1 功能性缺陷
-
-| # | 问题 | 位置 | 严重度 |
-|---|------|------|--------|
-| P1 | `InMemoryGraph.NavigateBiDir` 是伪实现，直接调用单向 BFS | `graph_mem.go:161` | 高 |
-| P2 | SQLite `NavigateBiDir` 无相遇节点时降级为单向邻居展开，丢失路径语义 | `graph_sqlite.go:430` | 中 |
-| P3 | 单向 BFS `Navigate` 仅返回边，不返回完整路径（无法区分"直接相邻"和"多跳路径"） | `graph_mem.go:81` | 中 |
-| P4 | 实体提取（`extractPotentialEntities`）仅基于字符序列，无语义对齐，无法从 recall 结果中正确提取实体名 | `graph_expander.go:102` | 高 |
-| P5 | 图扩展与 recall 结果的融合仅靠固定权重 0.5，缺乏语义相关性过滤 | `graph_expander.go:38` | 中 |
-
-### 3.2 性能问题
-
-| # | 问题 | 位置 | 严重度 |
-|---|------|------|--------|
-| L1 | SQLite BFS 每次跳数需要独立 SQL 查询，N 跳 = N 次 DB 往返 | `graph_sqlite.go:225` | 中 |
-| L2 | 无连接池或批量查询优化，大图谱（>10K 节点）多跳延迟会显著上升 | 全局 | 低 |
-| L3 | 无缓存层，相同实体的重复 BFS 查询无法复用 | 全局 | 低 |
-
----
-
-## 4. 增强设计方案
-
-### 4.1 修复 InMemoryGraph.NavigateBiDir
-
-**问题**：当前直接委托单向 BFS，双向 BFS 逻辑完全缺失。
-
-**方案**：
-
-```go
-// 在 graph_mem.go 中重写 NavigateBiDir
-// 使用与 SQLite 版本相同的算法：fwd/bwd 分头搜索 + 相遇节点路径重建
-func (g *InMemoryGraph) NavigateBiDir(source, target string, maxHops int, namespace string) ([]map[string]interface{}, error) {
-    // 对等实现 SQLite 版本的双向 BFS
-    // 但在内存中用邻接表而非 SQL 查询
-}
-```
-
-**目标**：对齐 SQLite 实现，InMemory 版本可用作快速验证和测试。
-
----
-
-### 4.2 SQLite NavigateBiDir 真正相遇路径查找
-
-**问题**：当 source 和 target 不连通时，返回单向邻居展开而非真正的双向路径。
-
-**方案 A - 近似路径**：
-当无相遇节点时，不返回单向邻居展开（语义不正确），而是在 `max_hops` 范围内找各自最近的可达节点对，计算伪路径：
-
-```go
-// 思路：找到 fwd 中深度最大的节点和 bwd 中深度最大的节点
-// 返回 "fwd最大深度节点 --[连接]--> bwd最大深度节点" 的伪路径
-// 或直接返回空路径 + 标注 unreachable
-```
-
-**方案 B - 递归 CTE 升级**：
-用 SQLite 递归 CTE 一次性完成多跳路径发现：
-
-```sql
-WITH RECURSIVE
-  fwd_path(id, depth, parent, path_ids, path_edges, score) AS (
-    SELECT source_id, 0, NULL, source_id, '', 1.0
-    FROM graph_edges WHERE source_id = ?
-    UNION ALL
-    SELECT e.target_id, fp.depth+1, fp.id,
-           fp.path_ids || ',' || e.target_id,
-           fp.path_edges || '|' || e.relation || ':' || CAST(e.weight AS TEXT),
-           fp.score * e.weight
-    FROM graph_edges e, fwd_path fp
-    WHERE e.source_id = fp.id AND fp.depth < ?
-  ),
-  bwd_path(id, depth, parent, path_ids, path_edges, score) AS (
-    -- 类似，反向
-  )
-SELECT * FROM fwd_path WHERE id IN (SELECT id FROM bwd_path)
-ORDER BY score DESC LIMIT 3;
-```
-
-**推荐**：方案 A（快速修复）+ 方案 B（长期升级，TODO）。
-
----
-
-### 4.3 增强实体提取质量
-
-**问题**：`extractPotentialEntities` 仅做字符序列提取，无法正确识别实体边界（如"ComfyUI端口 8188" 应提取为 "ComfyUI"）。
-
-**方案**：引入轻量 NER 组件，有两条路：
-
-| 方案 | 实现 | 优缺点 |
-|------|------|--------|
-| 轻量规则 NER | 正则 + 词典（预定义实体类型：软件、端口、路径、用户名等） | 无外部依赖，速度快；对预定义模式效果好 |
-| 向量相似度对齐 | 用 recall 结果的向量与图谱中已有节点名做相似度匹配 | 可发现同义词/变体，但需要 embedding 服务 |
-
-**推荐**：先实现方案 A（规则 NER），在 `graph_expander.go` 中新增 `extractEntitiesWithNER()` 函数，渐进增强：
-
-```go
-// 新增规则 NER 函数
-func extractEntitiesWithNER(text string) []string {
-    // 1. 已有字符序列提取
-    // 2. 正则匹配：软件名（字母数字组合）、端口号、URL、路径等
-    // 3. 与图谱已有节点名做前缀匹配（快速候选过滤）
-    // 4. 返回高置信度实体列表
-}
-```
-
----
-
-### 4.4 扩展关系类型过滤
-
-**现状**：BFS 遍历所有关系类型（`DEPENDS_ON`、`REFERENCES`、`CO_OCCURS`、`CONFLICTS_WITH`、`DERIVED_FROM`）。
-
-**场景需求**：
-- 因果追溯：只走 `DEPENDS_ON` 边
-- 共现扩展：只走 `CO_OCCURS` 边
-- 冲突检测：只走 `CONFLICTS_WITH` 边
-
-**方案**：
-
-```go
-// GraphStore 接口扩展
-Navigate(entity string, maxHops int, namespace string, relationFilter []string) ([]map[string]interface{}, error)
-NavigateBiDir(source, target string, maxHops int, namespace string, relationFilter []string) ([]map[string]interface{}, error)
-
-// 调用方（ExpandWithSummary）传入关系类型白名单
-```
-
-对 SQLite 版本，只需在 SQL `WHERE` 子句增加 `AND e.relation IN ('A', 'B')` 即可。
-
----
-
-### 4.5 Recall 管线增强：图扩展与语义结果融合
-
-**现状**：
-- 图扩展仅在 recall 结果 < 5 条时触发（`graph_expander.go`）
-- 扩展结果以固定 0.5 权重与 recall 结果混合
-
-**方案**：
-
-```go
-// RecallPipeline.EnhancedRecallWithGraph 扩展方法
-// 1. 获取语义 recall 结果（top-K）
-// 2. 从 top-K 中提取候选实体
-// 3. 对每个实体执行双向 BFS（maxHops=2）
-// 4. 收集所有相遇路径，构建 {节点: 边集合} 映射
-// 5. 对每个扩展节点计算 "图谱相关性分数" = Σ(路径权重 × 跳数衰减)
-// 6. 与语义分数做加权融合（λ × semantic + (1-λ) × graph）
-// 7. 去重（已有 recall 结果 ID 跳过）
-// 8. 返回扩展后结果 + GraphBFSResult（汇总语句）
-```
-
-融合权重 `λ` 建议：
-- 高语义相关性（recall top 结果 > 0.8）：λ = 0.8（信任语义）
-- 中语义相关性（0.5 ~ 0.8）：λ = 0.5（平衡）
-- 低语义相关性（< 0.5）：λ = 0.3（更信任图扩展）
-
----
-
-### 4.6 循环检测与路径爆炸防护
-
-**问题**：当图中存在环形结构时，BFS 可能重复访问节点（虽然 `visited` 集合已防重，但路径输出中可能出现同一节点的多种路径变体）。
-
-**方案**：
-- 有向图模式：当前 `NavigateBiDir` 实际上按无向图处理（Source/Target 的边都走），但实际图中 `DEPENDS_ON` 是有方向的，`REFERENCES` 可能也是有向的
-- **统一处理**：MemoryWeave 的边本身是双向可遍历的（因为 `NavigateBiDir` 无论 source → target 还是 target → source 都走），所以无向图模型是合理的
-- **路径爆炸防护**：增加 `max_paths` 参数限制返回数量（当前硬编码 3 条）；增加 `max_nodes_per_hop` 限制每跳最多探索节点数（防止高度连通节点导致扇出爆炸）
-
----
-
-### 4.7 性能优化：递归 CTE vs 应用层 BFS
-
-**现状**：SQLite BFS 在应用层做循环 + 多次 SQL 查询（每跳一次）。
-
-**方案**：用 SQLite 递归 CTE 一次性完成 BFS 遍历，减少 DB 往返：
-
-```sql
--- 单源 BFS 递归 CTE（代替当前逐跳循环）
-WITH RECURSIVE bfs(node_id, depth, parent_edge, path) AS (
-    -- 初始化：起点
-    SELECT source_id, 0, NULL, source_id
-    FROM graph_nodes WHERE id = ?
-    
-    UNION ALL
-    
-    -- 递归：扩展邻居
-    SELECT e.target_id, b.depth + 1, e.id,
-           b.path || ' -> ' || e.target_id
-    FROM graph_edges e, bfs b
-    WHERE e.source_id = b.node_id
-      AND b.depth < ?
-      AND e.namespace = ?
-)
-SELECT * FROM bfs ORDER BY depth;
-```
-
-**预期效果**：N 跳 BFS 从 N 次 SQL 往返减少为 1 次，延迟降低约 50%（在网络 RTT 明显时效果更显著）。
-
----
-
-## 5. 实施计划（E1 子任务分解）
-
-| 阶段 | 内容 | 优先级 | 复杂度 |
-|------|------|--------|--------|
-| E1.1 | 修复 `InMemoryGraph.NavigateBiDir` 伪实现，对齐 SQLite 算法 | P1 | 低 |
-| E1.2 | SQLite `NavigateBiDir` 无相遇路径时正确处理（返回 unreachable + 最近的可达节点对） | P2 | 中 |
-| E1.3 | 新增 `extractEntitiesWithNER` 规则 NER，提升实体提取质量 | P1 | 中 |
-| E1.4 | `Navigate`/`NavigateBiDir` 接口增加 `relationFilter` 参数 | P3 | 低 |
-| E1.5 | `RecallPipeline` 集成 `ExpandWithSummary`，实现语义 + 图扩展分数融合 | P2 | 中 |
-| E1.6 | SQLite BFS 升级为递归 CTE 实现（性能优化） | P4 | 高 |
-| E1.7 | 增加循环检测和路径爆炸防护参数 | P3 | 低 |
-
----
-
-## 6. 附录
-
-### 6.1 参考项目速查表
-
-| 项目 | 语言 | 图存储 | 多跳算法 | 特点 |
-|------|------|--------|---------|------|
-| [Graphiti](https://github.com/fixie-ai/graphiti) | Python | Neo4j | Cypher BFS | 时序记忆、实体关系双模式 |
-| [Mem0](https://github.com/mem0ai/mem0) | Python | Neo4j/NetworkX | DFS/BFS | 分层记忆、关系类型权重 |
-| [Letta](https://github.com/letta-ai/letta) | Python | SQLite | 递归 CTE | 持久化、SQL 记忆 |
-| [Cortex](https://github.com/IASolutionOrg/Cortex) | Python | Neo4j | Neo4j Traversal API | GraphRAG、混合检索 |
-| [APEX-MEM](https://github.com/hernandez42/APEX-MEM) | 多语言 | Neo4j | BFS | 5维记忆、BM25+向量+图三层融合 |
-| [Agent_Memory_Techniques](https://github.com/NirDiamant/Agent_Memory_Techniques) | Jupyter | 综述 | 综述 | 30 种记忆模式对比研究 |
-
-### 6.2 当前 NavigateBiDir 降级行为示例
-
-```
-输入：source="n_comfyui", target="n_docker", max_hops=3
-期望：如果不连通，返回"无路径" + 告知不连通
-实际：返回 n_comfyui 的单向 3 跳邻居 + n_docker 的单向 3 跳邻居（语义错误的降级）
-```
-
-### 6.3 Recall 链路中 BFS 扩展的位置
-
-```
-Recall 管线：
-  1. bge-m3 编码
-  2. LanceDB ANN 搜索
-  3. bge-reranker 重排  
-  4. MMR 多样性去重
-  5. [E1 增强] 图谱 BFS 扩展（ExpandWithSummary） ← 这里
-  6. 记忆预取（CO_OCCURS > 0.6）
-  7. 返回结果 + GraphBFSResult 汇总
-```
-
-### 6.4 关键代码位置索引
-
-| 文件 | 行号 | 内容 |
-|------|------|------|
-| `go/internal/governance/graph_store.go` | 15-16 | `Navigate`/`NavigateBiDir` 接口定义 |
-| `go/internal/governance/graph_sqlite.go` | 211-243 | SQLite 单源 BFS |
-| `go/internal/governance/graph_sqlite.go` | 249-436 | SQLite 双向 BFS（含路径重建） |
-| `go/internal/governance/graph_mem.go` | 55-94 | 内存单源 BFS |
-| `go/internal/governance/graph_mem.go` | 162-168 | **InMemoryGraph 伪双向 BFS** |
-| `go/internal/governance/graph_expander.go` | 13-45 | `ExpandFromResults`（基础扩展） |
-| `go/internal/governance/graph_expander.go` | 48-99 | `ExpandWithSummary`（增强扩展 + 汇总） |
-| `go/internal/storage/recall.go` | 58-115 | Recall 管线主逻辑 |
-| `go/internal/api/routes/graph.go` | 71-115 | HTTP API 层 navigate 接口 |
-| `go/internal/models/memory.go` | 101-115 | `GraphBFSResult` / `ExpandedRelation` 数据结构 |

docs/concepts/data_structure.md

@@ -1,49 +0,0 @@
-# concepts — 核心概念设计文档
-
-## 用途
-存放小唯知识库体系的核心设计文档，涵盖织忆(MemoryWeave)记忆系统、MemoryFabric 设计体系、高考志愿系统、恢复操作手册等关键概念定义和架构设计。
-
-## 文件说明
-
-### 织忆(MemoryWeave) 核心设计
-
-| 文件名 | 描述 |
-|--------|------|
-| `织忆(MemoryWeave)-v3.8-完整定稿.md` | **核心设计文档** — v3.8 完整设计定稿，63KB，织忆系统架构、API、数据流 |
-| `织忆(MemoryWeave)-v3.0-完整定稿.md.bak` ~ `.bak4` | v3.0 历史备份（4 个版本迭代） |
-| `织忆(MemoryWeave)-v3.1-完整定稿.md.bak1` ~ `.bak3` | v3.1 历史备份（3 个版本迭代） |
-| `Hermes迁移织忆计划-v1.0.md` | **迁移计划** — 将织忆系统迁移到 Hermes Agent 的方案 |
-| *(v3.9 rag-skill 补充设计)* | ⚠️ 任务提及但磁盘上未找到，待创建 |
-
-### MemoryFabric 设计体系
-
-| 文件名 | 描述 |
-|--------|------|
-| `MemoryFabric-设计方案.md` | 初始设计方案 |
-| `MemoryFabric-v2.0-完整设计方案.md` | v2.0 完整版 |
-| `MemoryFabric-v2.0-整合设计方案.md` | v2.0 整合版 |
-| `MemoryFabric-v2.1-整合设计方案.md` | v2.1 整合版 |
-| `MemoryFabric-v2.2-整合设计方案.md` | v2.2 整合版 |
-| `MemoryFabric-v2.3-整合设计方案.md` | v2.3 整合版 |
-| `MemoryFabric-v2.4-完整定稿.md` | v2.4 完整定稿 |
-| `MemoryFabric-v2.5-完整定稿.md.bak` | v2.5 备份 |
-| `MemoryFabric-v2-自优化设计方案.md` | 自优化设计方案 |
-
-### 其他概念文档
-
-| 文件名 | 描述 |
-|--------|------|
-| `高考志愿网站-备忘.md` | 高考助手网站维护备忘 |
-| `小唯恢复操作手册.md` | 小唯系统故障恢复操作步骤 |
-| `小唯恢复指南.md` | 小唯系统恢复指南 |
-| `织忆备份恢复方案.md` | 织忆数据备份和恢复方案 |
-| `织忆部署清理工作笔记.md` | 织忆部署和清理操作记录 |
-| `织忆系统修复工作记录.md` | 织忆系统修复过程记录 |
-| `cli-anything-zhiyi-使用指南.md` | cli-anything 框架下织忆 CLI 的使用指南 |
-
-## 数据范围
-- **设计阶段**: v2.0 → v3.8（MemoryFabric → MemoryWeave）
-- **文档数量**: 28 个文件（含备份）
-- **活跃文档**: 10 个（非 bak 文件）
-- **总数据量**: ~788KB
-- **备份文件**: 9 个 `.bak` / `.bakN` 文件（保留历史版本）

docs/consolidate-fix-log.md

@@ -1,133 +0,0 @@
-# 织忆 consolidate 修复工作记录
-> 日期：2026-05-31
-> 目标：修复 consolidate cronjob 监控发现的问题
-
----
-
-## 问题清单（来自 cronjob 报告）
-
-| 项目 | 状态 | 说明 |
-|------|------|------|
-| prune "no such column" 错误 | ✅ 已修复 | 日志中无 prune 报错 |
-| DBSCAN 聚类数量 | ❌ 仍是 1 | `1 clusters + 0 noise from 1477 items` |
-| quality 分数 | ❌ 仍是 0.000 | 但 `task=full` 时 Step 4 有执行 |
-| decay 校准 | ✅ 正常 | 12 个类别 decay_rates 有值 |
-
----
-
-## 根因分析
-
-### 1. DBSCAN 始终 1 cluster
-**根因：所有 1477 条向量全为零向量（norm=0.000）**
-
-Python migration 时用 JSON 数组写入 LanceDB FixedSizeList 列，但 Arrow 读取返回 null，全部 fallback 到 `vec![0.0; 1024]`。零向量之间 L2 距离恒为 0，任何 eps 值都无法产生多 cluster。
-
-**证据（sidecar 日志）：**
-```
-[consolidate] vector norms: min=-0.0000 max=0.0000 avg=0.0000
-[consolidate] sample distances (20 vecs, 190 pairs): p5=-0.000 p50=-0.000 p95=-0.000
-```
-
-### 2. quality=0.000
-**不是 bug**：Go API 返回的 `quality_score` 字段来自 `ConsolidationReport` 结构体，而 Rust 的质量分存在 `QualityBacktracer` 返回值中，需要从 `report_json` 字段解析。当前 Step 4 有执行（见 sidecar 日志），但 API 响应字段名不匹配。
-
----
-
-## 已修复的问题
-
-### ✅ Go → Rust mode 传递（1fa8349）
-- `consolidation_pipe.go`：`RunWithMode(mode)` 正确传递 task 给 IPC
-- Rust sidecar：收到的 `task="full"` 日志已确认
-
-### ✅ BGE HTTP 连通性检查（1fa8349）
-- Step 4 前用 `TcpStream::connect_timeout(2s)` 检测 port 8000
-- 不通时跳过质量回溯，不挂起
-
-### ✅ embed.rs 请求超时（1fa8349）
-- `.timeout(Duration::from_secs(10))` 防止无限等待
-
-### ✅ WriteTimeout 60s（1fa8349）
-- Go server.go：`WriteTimeout` 从 10s → 60s（之前 exit 52 根因）
-
-### ✅ LanceDB FixedSizeList 存储格式（1fa8349）
-- `insert_batch` 改用 `Float32Array::from_iter_values` + `try_new`
-- 仅影响新写入，历史向量仍需重新编码
-
-### ✅ DBSCAN eps 调整（1fa8349）
-- eps 从 1.5 → 0.1（cosine threshold 0.995）
-- 等向量修复后需要重新调 eps
-
-### ✅ nil guards（1fa8349）
-- `consolidation_pipe.go`：防止 report 为 nil 时 panic
-
----
-
-## 当前状态（2026-05-31）
-
-```
-cluster_only: ✅ 正常（7-8s 完成）
-full mode:    ✅ Step 1-5 全部执行（decay 正常，quality 有执行但 API 字段不匹配）
-task=full     ✅ mode 正确传到 Rust
-```
-
----
-
-## 待解决问题
-
-### 🔴 P0: 1477 条向量重新编码
-LanceDB 中 1477 条历史向量全为零，修复后：
-1. BGE HTTP 服务（embed-server.py port 8000）需恢复正常
-2. 批量读取 1477 条记忆内容
-3. 用 BGE 编码得到 1024-dim 向量
-4. 写回 LanceDB
-
-### 🟡 P1: DBSCAN eps 重新调参
-向量修复后，基于真实距离分布重新找合适 eps 值（当前 eps=0.1 可能过于严格）。
-
-### 🟡 P2: embed-server.py 启动问题
-当前 `embed-server.py`（pid=917）在 port 8000 但 `/v1/embeddings` 请求超时（curl exit 28）。进程 5.4GB RAM 表明模型可能已加载但 encode 调用挂起。需要修复或替换为 Rust ONNX 实现。
-
----
-
-## 技术细节
-
-### IPC 协议
-```json
-{"type":"consolidate","consolidate":{
-  "task":"full",
-  "lancedb_path":"/var/lib/memoryweave",
-  "sqlite_path":"/var/lib/memoryweave/graph.db",
-  "llm_endpoint":"...",
-  "llm_model":"...",
-  "llm_api_key":"...",
-  "llm_budget":20,
-  "epsilon":0.1,
-  "min_points":3,
-  "model_dir":"/home/muc/models/bge-m3/onnx"
-}}
-```
-
-### DBSCAN eps 数学
-对于 1024-dim BGE-M3 单位向量：
-- euclidean² = 2(1-cosine)
-- cosine = 1 - euclidean²/2
-- eps=0.1 → cosine > 0.995（很严格，几乎相同才聚一起）
-- eps=0.5 → cosine > 0.875
-- eps=1.0 → cosine > 0.5
-- eps=1.5 → cosine > 0（几乎全聚一起）
-
-### Git Commit
-```
-1fa8349 fix: mode propagation, eps=0.1, BGE connectivity check, vector storage, WriteTimeout 60s
-```
-
----
-
-## 定时器配置
-
-- `zhiyi-consolidate.timer`：每周日 03:00 执行 `zhiyi-consolidate.service --mode full`
-- 90s cluster_only 定时器：已不存在（之前某个阶段的遗留设计）
-
----
-
-*最后更新：2026-05-31 15:50*

docs/data_structure.md

@@ -1,40 +0,0 @@
-# 07-Wiki 知识库 — 顶层索引
-
-## 用途
-小唯外脑的结构化知识库，存储设计文档、同步记录、图谱知识、工作流程等持久化知识资产。07-Wiki 是小唯的"第二大脑"核心仓库，作为 Obsidian 知识体系的一部分。
-
-## 子目录
-
-| 子目录 | 用途 | 状态 |
-|--------|------|------|
-| `concepts/` | 核心概念设计文档（MemoryFabric、织忆(MemoryWeave)、高考志愿系统等） | ✅ 活跃 |
-| `织忆同步/` | 织忆(MemoryWeave) 运行时同步记录和日志 | ✅ 活跃 |
-| `织忆图谱/` | 织忆知识图谱 — 记忆节点、关联关系、图谱索引 | ✅ 活跃 |
-| `经证同步/` | 经证（JingZheng）模块同步记录 | ✅ 活跃 |
-| `练念同步/` | 练念（LianNian）模块同步记录 | ✅ 活跃 |
-| `绸忆同步/` | 绸忆（ChouYi）模块同步记录 | ✅ 活跃 |
-| `绍态同步/` | 绍态（ShaoTai）模块同步记录 | ✅ 活跃 |
-| `终忆同步/` | 终忆（ZhongYi）模块同步记录 | ✅ 活跃 |
-| `zhiyi-sync/` | 织忆同步（英文别名目录） | ✅ 活跃 |
-| `ZhiyiSync/` | 织忆同步（英文别名目录） | ✅ 活跃 |
-| `zhi-yi-tong-bu/` | 织忆同步（拼音别名目录） | ✅ 活跃 |
-| `流程/` | 业务流程文档（如 KOCR 凭证识别流程） | ✅ 活跃 |
-| `探索/` | 技术探索/调研笔记（如 LayoutXLM 方案） | ✅ 活跃 |
-| `ABC/` | 测试记忆数据 | ✅ 活跃 |
-| `ontology/` | 本体论 / 知识体系定义 | ⬜ 空 |
-| `test/` | 测试文件 | ⬜ 少量 |
-| `tools/` | 工具文档索引（计划中） | 🆕 新建 |
-| `learn/` | 学习笔记（计划中） | 📅 待建 |
-| `references/` | 参考资料（计划中） | 📅 待建 |
-
-## 顶层文件
-
-| 文件 | 说明 |
-|------|------|
-| `index.md` | 原导航页 — 指向 concepts 等核心目录 |
-| `data_structure.md` | **本文件** — 知识库数据结构索引 |
-
-## 数据范围
-- **领域**: 小唯知识库系统、织忆(MemoryWeave) 记忆系统、MemoryFabric 设计体系、高考志愿系统、ComfyUI、各种 AI 工具链
-- **文件数**: 2000+ 文件（含大量同步记录日志）
-- **同步记录**: 约 8 个同步目录，每个包含数百条运行时日志

docs/fix-consolidation-storm-20260810.md

@@ -1,66 +0,0 @@
-# 织忆 Consolidation 风暴修复 — 实施计划
-
-> 2026-08-10 | 小唯 | 优先级：P0（recall API 不可用）
-
-## 问题
-
-zhiyid CPU 80-90%，recall/memories API 超时（HTTP 000 / 120s+），journalctl 每 15-60s 一次 `[consolidation] Rust sidecar 完成` + `PageRank 更新: 10341 nodes`。
-
-## 根因（已源码定位）
-
-1. **server.go:1113-1125**：30s ticker 检查 7 个触发器
-2. **triggers.go**：`t_distill` cooldown = **60s**，`t_merge` = 10min
-3. **consolidation_pipe.go:46-48**：`Run()` → `cluster_only` 模式
-4. **rust/main.rs:374-404**：cluster_only 每次 `lancedb.search(&zero_vec, 10000)` 加载**全部 10000 条向量** + DBSCAN 全量聚类 + PageRank
-
-**风暴机制**：t_distill 每 60s 触发 → 全量聚类（数据量大时单次 30-60s）→ 还没跑完下一轮又触发 → CPU 堆积，HTTP 排队超时。
-
-## 修复方案（选 A：最小改动，立竿见影）
-
-### A. 调大 distill 触发器 cooldown（60s → 15min）
-
-**文件**：`go/internal/api/routes/triggers.go`
-
-```go
-// 修改 cooldownMap
-TriggerDistill:       time.Minute,      // 改为 15 * time.Minute
-```
-
-**影响**：
-- 蒸馏批量处理从每 60s 一次 → 每 15min 一次（数据仍在队列，不会丢）
-- cluster_only 全量聚类从每 60s → 每 15min（CPU 风暴消除）
-- distill 的"5min 无蒸馏 → 批量"逻辑仍可触发（是另一条路径）
-
-### B. （可选增强）cluster_only 无新写入跳过
-
-**文件**：`go/internal/api/routes/consolidation_pipe.go`
-
-在 Run() 前检查 `ldb.Stats()["total_episodes"]` 与上次相比无增长 → 直接 return 空报告。防止 15min 间隔内仍频繁全量跑。
-
-## 改动清单
-
-| 文件 | 改动 |
-|------|------|
-| `go/internal/api/routes/triggers.go` | TriggerDistill cooldown 60s → 15min |
-| （B）`go/internal/api/routes/consolidation_pipe.go` | cluster_only 无新写入跳过 |
-
-## 编译部署
-
-```bash
-cd /tmp/memoryweave/go && go build -o zhiyid-new ./cmd/zhiyid
-# 成功 → 复制
-systemctl --user stop zhiyid
-cp zhiyid-new /home/muc/bin/zhiyid-new
-systemctl --user start zhiyid
-# 验证
-curl -s -H "X-API-Key: zhiyi-dev-key-2026" http://localhost:7821/api/v1/health
-ps aux | grep zhiyid-new | grep -v grep  # CPU 应 < 20%
-```
-
-## 验证标准
-
-1. `systemctl --user status zhiyid` → active (running)
-2. CPU 稳定 < 20%（之前 80-90%）
-3. recall API 10s 内响应（之前 120s+ 超时）
-4. 日志 consolidation 频率：≥15min 一次（之前 15-60s）
-5. memory_write → 5-10s → recall 能命中新写入

docs/h1-h3-h4-h5-plan.md

@@ -1,101 +0,0 @@
-# H1 + H3 + H4 + H5: Go 后端改进
-
-## 修改文件
-
-### 1. `/tmp/memoryweave/go/internal/storage/recall.go` (H1: BM25)
-
-在 `Recall` 方法中，Step 4 (MMR) 之前，对 candidates 计算 keyword score：
-
-```go
-// Step 3.5: BM25 keyword scoring — 补充向量搜索
-if len(candidates) > 0 {
-    for i := range candidates {
-        kwScore := computeBM25Score(query, candidates[i].Content)
-        // 融合分数：0.7 * 向量语义分 + 0.3 * 关键词分
-        candidates[i].QualityScore = candidates[i].QualityScore * 0.7 + kwScore * 0.3
-    }
-}
-```
-
-新增函数：
-```go
-// computeBM25Score 基于词频的关键词匹配分数
-func computeBM25Score(query, doc string) float64 {
-    queryTerms := strings.Fields(strings.ToLower(query))
-    docLower := strings.ToLower(doc)
-    hitCount := 0
-    for _, term := range queryTerms {
-        if len(term) < 2 { continue }
-        count := strings.Count(docLower, term)
-        if count > 0 { hitCount += count }
-    }
-    if hitCount == 0 { return 0 }
-    // 归一化到 [0, 1]
-    score := float64(hitCount) / float64(len(queryTerms))
-    if score > 1.0 { score = 1.0 }
-    return score
-}
-```
-
-### 2. `/tmp/memoryweave/go/internal/api/routes/core.go` (H3 + H4 + H5)
-
-#### H3: 自动信任评分
-在 `Recall` handler 末尾（respond 之前），异步更新信任评分：
-```go
-// H3: 异步更新信任评分
-go func() {
-    if err := a.GraphStore.UpdateEdgeTrustScores(); err != nil {
-        log.Printf("[zhiyid] update trust scores: %v", err)
-    }
-}()
-```
-
-#### H4: 默认 diversity
-修改 Recall handler 中的 diversity 默认值：
-```go
-// 在解析请求体后
-if req.Diversity <= 0 {
-    req.Diversity = 0.3  // 默认0.3，在相关性和多样性间平衡
-}
-```
-
-#### H5: 混合搜索模式
-在请求体中新增 `mode` 字段：
-```go
-type RecallRequest struct {
-    Query     string  `json:"query"`
-    Limit     int     `json:"limit"`
-    TopK      int     `json:"top_k"`
-    Namespace string  `json:"namespace"`
-    AgentID   string  `json:"agent_id"`
-    Diversity float64 `json:"diversity"`
-    Mode      string  `json:"mode"`  // "hybrid"(default), "semantic", "keyword"
-}
-```
-
-根据 mode 做不同输入：
-- "semantic" 或 "" → 只走向量搜索（当前行为）
-- "keyword" → 走 graph.db FallbackTextSearch（关键词搜索）+ BM25 scoring
-- "hybrid"（默认）→ 向量 + BM25 combined（H1 实现）
-
-### 3. `/tmp/memoryweave/go/internal/governance/graph_sqlite.go` (H5: keyword 搜索增强)
-
-增强 `FallbackTextSearch`：
-- 当前只搜 node.name + relation
-- 新增搜索 edges 的 properties JSON 中的 content 字段
-- 按 keyword match count 排序
-
-## 验证
-```bash
-# Hybrid mode (默认)
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -d '{"query":"memory sidecar","top_k":3}' http://localhost:7821/api/v1/recall
-
-# Keyword mode
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -d '{"query":"memory sidecar","top_k":3,"mode":"keyword"}' http://localhost:7821/api/v1/recall
-
-# Semantic mode
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -d '{"query":"memory sidecar","top_k":3,"mode":"semantic"}' http://localhost:7821/api/v1/recall
-
-# Diversity (默认0.3)
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -d '{"query":"memory","top_k":5}' http://localhost:7821/api/v1/recall
-```

docs/h2-llm-wiki-plan.md

@@ -1,66 +0,0 @@
-# H2: LLM 驱动的 Wiki 策展
-
-## 修改文件
-
-### `~/.hermes/scripts/wiki_curator.py`
-
-在现有启发式提取基础上，新增 `--llm` 模式调用 NewAPI。
-
-#### 1. 配置
-
-```python
-# LLM 配置
-LLM_API = "http://127.0.0.1:3000/v1/chat/completions"
-LLM_MODEL = "minimaxai/minimax-m3"
-LLM_KEY = "sk-0Ex...MWBP"  # 从 ~/.hermes/config.yaml 读取
-```
-
-从 `~/.hermes/config.yaml` 读取 key（避免硬编码）：
-```python
-import yaml
-with open(os.path.expanduser("~/.hermes/config.yaml")) as f:
-    cfg = yaml.safe_load(f)
-llm_key = cfg.get("providers", {}).get("newapi-local", {}).get("api_key", "")
-```
-
-#### 2. 新增参数
-```python
-parser.add_argument("--llm", action="store_true", help="Use LLM for extraction (default: heuristic)")
-```
-
-#### 3. LLM 提取函数
-```python
-def extract_with_llm(content: str, filepath: str) -> dict:
-    """调用 NewAPI LLM 提取结构化知识"""
-    prompt = f"""Analyze the following technical document and extract knowledge.
-Return JSON only with this exact structure:
-{{
-  "concepts": [{{"name": "...", "summary": "...", "details": "..."}}],
-  "entities": [{{"name": "...", "attributes": {{...}}}}],
-  "relations": [{{"source": "...", "relation": "uses|contains|depends_on|implements|part_of", "target": "..."}}]
-}}
-
-Document: {content[:3000]}
-"""
-    resp = requests.post(LLM_API, 
-        headers={"Authorization": f"Bearer {LLM_KEY}", "Content-Type": "application/json"},
-        json={"model": LLM_MODEL, "messages": [{"role": "user", "content": prompt}], "temperature": 0.1},
-        timeout=30)
-    # 解析 JSON 响应
-    ...
-```
-
-#### 4. 提取逻辑
-- 用 `--llm` → 优先 LLM 提取，LLM 失败/超时 → 回退到启发式
-- 不用 `--llm` → 当前启发式行为
-
-## 验证
-```bash
-# LLM 模式
-python3 ~/.hermes/scripts/wiki_curator.py --dir /tmp/test-wiki --llm --force
-
-# LLM 模式 dry-run
-python3 ~/.hermes/scripts/wiki_curator.py --dir /tmp/test-wiki --llm --dry-run
-
-# 检查提取质量（LLM 应产出比启发式更精准的概念）
-```

docs/hit-outcome-signal.md

@@ -1,89 +0,0 @@
-# hits+/hits− outcome 信号定义（GA-P0-4 · t_bb10e8bc）
-
-> 一句话：hits+/hits− 是**独立、语义单一**的「真实 outcome」信号，供 P2 自适应阈值做
-> 有意义的拟合。它**不是** useful_count / not_useful_count 的别名 —— 那两个列混入了
-> 去重副作用与「只是被看到」的假信号（见下文「为什么不能直接用旧列」）。
-
-## 1. 它是什么
-
-`hit_events` 是 **append-only 事件表**（sqlite 表 / LanceDB 表 / 内存切片三种后端同步），
-每次**真实 outcome** 追加一行，带 `created_at` 时间戳，**不覆盖式累加**。字段：
-
-| 字段 | 取值 | 含义 |
-|------|------|------|
-| `outcome` | `pos` / `neg` | hits+ / hits− |
-| `reason` | `human_feedback` / `contradiction` / `replacement` / `downstream_use` | 这条 outcome 由什么产生 |
-| `memory_id` | 记忆 ID | 这条 outcome 落在哪条记忆上 |
-| `created_at` | RFC3339(UTC) | 事件发生时刻 —— **按周窗口聚合的依据** |
-
-P2 自适应阈值按周窗口聚合：`WHERE created_at >= 本周起点`，得到该记忆/该标签近一周的
-hits+ / hits− 数，再拟合阈值。因为事件带时间戳且 append-only，周窗口天然可算（老窗口
-自然滑出，不污染当前拟合）。
-
-## 2. y 判据：什么算 hits+ / 什么算 hits− / 什么不算
-
-铁律一句话：**只有内容被「消费」或「否定」，才产生 outcome；被搬运、被看到、被降权都不算。**
-
-### hits+（`outcome="pos"`）—— 被真实使用/认可
-1. **human_feedback**：用户对召回结果点「有用」（`/feedback/useful`）、或「修正」（`/feedback/correct`）
-2. **downstream_use**：下游流程**实际引用**了这条记忆的内容（写代码/写文档/决策时真正用上）
-3. **contradiction（正面）**：后续对话中它被反复印证、未被推翻
-
-### hits−（`outcome="neg"`）—— 被真实否定/取代
-1. **human_feedback**：用户对召回结果点「没用」（`/feedback/not-useful`）
-2. **contradiction**：后续对话中它与更可信的信息**冲突并被淘汰**（`delete_reason=contradiction`）
-3. **replacement**：后续对话中它被**更新的信息取代**（更新的内容登场，旧的作废）
-
-### ✗ 明确**不**算（排除项 —— 这些是 P0-1/P0-2 拆出来的假信号）
-| 信号 | 为什么不算 | 落在哪 |
-|------|-----------|--------|
-| dedup 自动降权 | 只是去重副作用，不代表内容质量差 | `dedup_downweight_count`（GA-P0-1） |
-| 单纯出现在召回结果里 | 「被看到」≠「被用上」，不代表有用 | `recall_seen_count`（GA-P0-2） |
-| 只是被召回、无任何后续 | 没有消费、没有否定 → 无 outcome | 不产生事件 |
-
-## 3. 为什么不能直接用旧列（等同不成立的证据）
-
-方案文档（`已办.md:16623`）曾写 `hits+ = useful_count`、`hits− = not_useful_count`、
-`V = hits+ + hits−`。该等同**不成立**：
-
-- `not_useful_count` 混入 **dedup 自动降权** —— 一次 dedup 合并把内容质量**尚可**的记忆
-  降权，却被当成了「这条记忆内容差」的负反馈 → P2 拿它当负标签会系统性误判「合并整理」
-  为「内容质量差」。
-- `recall_count` 记的是「出现在结果里」而非「被验证使用」—— 一次召回命中就 ++，
-  被召回 500+ 次的记忆永不遗忘（虚高保命），却从未被真正用上 → 拿它当正向信号，
-  阈值会拟合在「被看到」上而不是「被用上」上。
-
-所以必须新建**只由真实 outcome 写入**的独立信号。本表就是它。
-
-## 4. 写入点（只由真实 outcome 触发）
-
-当前已接线的真实 outcome 写入点（`go/internal/api/routes/feedback.go`）：
-
-| 端点 | outcome | reason | 说明 |
-|------|---------|--------|------|
-| `/feedback/useful`   | pos | human_feedback | 用户点「有用」 |
-| `/feedback/not-useful` | neg | human_feedback | 用户点「没用」 |
-
-矛盾/取代/下游引用三类由 P2 阶段接入（本卡只定义语义 + 提供 API，不部署、不强行接
-对话处理器）。
-
-## 5. 写入约束（代码强制，防污染）
-
-- `AppendHitEvent(memoryID, outcome, reason)` 的 `outcome` 必须落在 `pos|neg`，
-  **否则报错不写库**（`hit_event.go:NormalizeHitOutcome`）—— 非法/混合语义值在源头被拦。
-- `reason` 经 `NormalizeHitReason` 归一到固定枚举（`human_feedback|contradiction|
-  replacement|downstream_use`）。
-- dedup 降权 / 单纯召回出现**禁止**调用本方法（它们在 P0-1/P0-2 已各有专属字段）。
-
-## 6. 实现位置
-
-| 层 | 文件 |
-|----|------|
-| Go 语义定义（枚举+归一化，单一真源） | `go/internal/storage/hit_event.go` |
-| Go 模型 | `go/internal/models/memory.go`（`HitEvent`） |
-| sqlite 后端 | `go/internal/storage/sqlite.go`（`hit_events` 表 + 3 方法） |
-| 内存后端 | `go/internal/storage/memvector.go`（`hitEvents` 切片 + 3 方法） |
-| Rust-LanceDB 后端 | `rust/src/lancedb_ops.rs`（`hit_events` 表 + 3 方法）· `rust/src/main.rs`（IPC） |
-| 真实 outcome 接线 | `go/internal/api/routes/feedback.go` |
-
-**禁部署**：本卡只落代码 + 测试 + 文档，不更新运行中的二进制、不碰 live 库。

docs/lightmem-p1-fact-extraction-plan.md

@@ -1,74 +0,0 @@
-# P1: 织忆蒸馏引擎 LightMem 式逐条事实提取改造
-
-> 2026-08-11 | 小唯 | 目标：把织忆 distill 从「整段摘要式提取」升级为「逐条事实提取」（借鉴 LightMem）
-> 优先级：P1（织忆 distill 质量的根本提升）
-
-## 目标（Goal）
-
-当前 `callLLM5D` 用单 prompt 做整段摘要（decisions/conclusions/actions 各≤3条），对长对话信息密度高的场景丢失细节。
-改造为 LightMem 式**逐条事实提取**：提取所有可独立成句的事实 + 保留全部实体细节 + 轻量上下文补全。
-
-## 修改文件（Files to modify）
-
-| 文件 | 修改 |
-|------|------|
-| `/tmp/memoryweave/go/internal/distill/engine.go` | `callLLM5D` prompt 重写 + LLMResponse 结构新增 FactsDetail |
-| `/tmp/memoryweave/go/internal/distill/engine.go` | `extractFacts` 保留（fallback），新增 facts 组装逻辑 |
-
-## 实现细节（Implementation details）
-
-### 1. 重写 `callLLM5D` 的 prompt（第 265-284 行）
-
-新 prompt 要点（LightMem METADATA_GENERATE_PROMPT 精华移植）：
-- 逐条判断：**"处理每条用户消息，判断是否含事实；除非纯问候/填充，否则都提取"**
-- 轻量上下文补全：`"My friend John is studying medicine"` → `"User's friend John is studying medicine."`
-- **保留全部具体细节**：全名/地点/事件/数字/公司名——"The Name of the Wind by Patrick Rothfuss" 不是 "a book"
-- 推断隐含信息：多个相关条目 → 推断一般模式，独立成条
-- 时间处理：mention time（说的时间）vs event time（发生时间）
-- 输出 JSON：`{"facts": [...], "entities": [...], "decisions": [...], "conclusions": [...], "is": 0.8, "su": 0.7, "pa": 0.6, "vd": 0.9, "ru": 0.7}`
-
-### 2. LLMResponse 结构
-
-- `Facts` 字段含义升级：从「1条整段摘要」→「多条独立事实」
-- 保持 `Decisions/Conclusions/ActionsTaken/OpenQuestions` 兼容（下游使用）
-
-### 3. extractFacts fallback 保留
-
-LLM 失败时仍走关键词+命名实体启发式（原逻辑不动）。
-
-## 测试命令（Test commands）
-
-```bash
-# 1. 编译
-cd /tmp/memoryweave/go && go build -o zhiyid-new ./cmd/zhiyid
-
-# 2. 单元测试（若有）
-cd /tmp/memoryweave/go && go test ./internal/distill/ -v 2>&1 | tail -20
-
-# 3. 部署
-systemctl --user stop zhiyid
-cp /tmp/memoryweave/go/zhiyid-new /home/muc/bin/zhiyid-new
-systemctl --user start zhiyid
-sleep 2
-
-# 4. 功能测试 — 提交一条含多事实的对话
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -H "Content-Type: application/json" \
-  -d '{"agent_id":"a06","content":"牧尘说小唯今天安装了ffmpeg用于语音转码，昨天研究了LightMem的架构，上周买了新显卡RTX 5080","metadata":{"source":"test"}}' \
-  http://localhost:7821/api/v1/commit
-
-# 5. 验证蒸馏质量 — 日志出现 facts ≥ 3 条 + entities 含具体实体
-journalctl --user -u zhiyid --no-pager -n 20 | grep distill
-
-# 6. recall 命中验证
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -H "Content-Type: application/json" \
-  -d '{"query":"ffmpeg 语音转码","top_k":3}' \
-  http://localhost:7821/api/v1/recall
-```
-
-## 验收标准
-
-- [ ] go build 通过
-- [ ] 部署后 7821 健康
-- [ ] 提交多事实内容后，日志显示 `LLM facts: N` 且 N ≥ 3（旧版只有 1）
-- [ ] recall 能命中具体实体（ffmpeg/RTX 5080/LightMem）
-- [ ] 蒸馏无 fallback（日志无 `LLMEndpoint empty` / `JSON parse error`）

docs/lightmem-p2p3-consolidate-buffer-plan.md

@@ -1,68 +0,0 @@
-# P2+P3: 织忆记忆离线整合 + 双缓冲触发改造
-
-> 2026-08-11 | 小唯 | 借鉴 zjunlp/LightMem（ICLR 2026）
-> 前置：P1 逐条事实提取已完成（commit 0734ffa）
-
-## P2: 离线整合 UPDATE_PROMPT（记忆合并/冲突消解）
-
-### 目标
-对相似记忆做 LLM 三选一决策（update 合并细节 / delete 冲突删旧 / ignore 不相关），解决记忆冗余和冲突。
-
-### 实现（新增 `go/internal/distill/consolidate.go`）
-
-1. **`ConsolidateMemory(ldb, llmConfig, namespace string)`** — 离线整合入口：
-   - `ldb.Search("memories", zeroVec, 200, namespace)` 取全部记忆
-   - 两两计算相似度（复用 bge 向量？简单方案：用 recall 端点向量检索找候选）
-   - 对高相似候选对（score ≥ 0.85）调 LLM 三选一
-2. **UPDATE_PROMPT**（移植 LightMem 原文精髓）：
-   - update：目标与候选描述同一事实但不完全一致 → 合并额外信息
-   - delete：直接冲突且候选更新 → 删目标
-   - ignore：不相关 → 跳过
-   - 输出 JSON `{"action": "update"|"delete"|"ignore", "new_memory": "..."}`
-3. **执行**：
-   - action=update → `UpdateMemoryContent(id, new_memory)`
-   - action=delete → `DeleteMemory(id)`
-   - action=ignore → 跳过
-4. **触发**：新增 API `POST /api/v1/consolidate/memory`（手动触发）+ 每日 cron 自动触发
-
-### 依赖
-- `ldb.Search` / `ldb.UpdateMemoryContent` / `ldb.Delete`（需确认 Delete 存在）
-
-## P3: 双缓冲触发（token 积累批量 distill）
-
-### 目标
-LightMem 的 Sensory(512) → Short-term(2000) 双缓冲思想：织忆 distill 按 token 积累触发，而非按条数。
-
-### 实现（改 `go/internal/distill/engine.go`）
-
-1. **Engine 新增字段**：
-   - `pendingTokens int` — 当前缓冲的累计 token 数
-   - `flushTokenThreshold int` — 触发阈值（默认 2000，对应 LightMem short-term）
-   - `maxBatchTokens int` — 单批上限（防止超大 batch）
-2. **Enqueue 改造**：
-   - 入队时累加 `pendingTokens += estimateTokens(content)`（rune count / 2 中文近似）
-   - `shouldFlush = pendingTokens >= flushTokenThreshold || len(queue) >= batchSize`
-   - flush 后 `pendingTokens = 0`
-3. **token 估算**：简单函数 `estimateTokens(s) = len([]rune(s))/2`（中文≈1 token/字符，英文≈1 token/4字符，取折中）
-
-### 配置
-- 通过环境变量 `DISTILL_FLUSH_TOKENS`（默认 2000）可调，避免硬编码
-
-## 测试命令
-
-```bash
-# P2 测试 — 触发手动整合
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -H "Content-Type: application/json" \
-  -d '{"namespace":"hermes-main"}' \
-  http://localhost:7821/api/v1/consolidate/memory
-
-# P3 测试 — 提交 3 条小内容（累计 <2000 token），验证不立即 flush
-# 再提交大内容触发 flush，看日志 flush START 时机
-```
-
-## 验收标准
-- [ ] go build 通过
-- [ ] P2: 手动触发后日志显示 update/delete/ignore 决策
-- [ ] P2: 相似记忆被合并（recall 不再返回重复内容）
-- [ ] P3: 小内容入队不立即 flush，达阈值才 flush
-- [ ] 部署后全链路健康

docs/memory-index/data_structure.md

@@ -1,18 +0,0 @@
-# 记忆 — 索引
-
-## 用途
-小唯核心记忆系统的顶层目录。汇聚"第二大脑"内存级数据：核心身份记忆文件（MEMORY.md）、织忆进度快照（织忆/）、MemoryFabric 设计文档（MemoryFabric/）。共 **4 个条目**（1 文件 + 2 子目录 + 1 全局指引）。
-
-## 文件清单
-
-| 路径 | 类型 | 说明 |
-|------|------|------|
-| `MEMORY.md` | 文件 | 小唯核心身份记忆 — 身份、环境、服务状态、飞书配置、Obsidian 外脑、重大事件 |
-| `织忆/` | 目录 | 织忆进度快照 — cron 进度报告、任务跟踪文件 |
-| `MemoryFabric/` | 目录 | MemoryFabric 设计体系 — 设计文档索引、参考项目、技术细节 |
-
-## 使用提示
-- `MEMORY.md` 是小唯启动时的核心上下文，包含所有关键环境变量和服务状态
-- 织忆/ 目录存储运行态进度快照，反映织忆当前迭代阶段
-- MemoryFabric/ 目录包含 MemoryFabric 体系的设计文档和参考项目
-- 该目录是记忆系统的最顶层，不直接存放大量文件，所有批量数据分散在子目录中

docs/memory-index/织忆/data_structure.md

@@ -1,17 +0,0 @@
-# 记忆/织忆 — 索引
-
-## 用途
-织忆（MemoryWeave）模块的进度快照目录。存储织忆系统的定期进度报告（cron 推送）和阶段性任务跟踪文件。共 **2 个文件**。
-
-## 文件清单
-
-| 文件 | 说明 |
-|------|------|
-| `cron-progress.md` | 织忆 cron 定时进度报告 — 记录系统运行状态、阶段性进展、待办事项 |
-| `task-phase1-1-models-queue.md` | Phase 1-1 模型队列任务 — 织忆第一阶段模型调度与队列管理的具体任务分解 |
-
-## 使用提示
-- 此目录由织忆的 cron 机制自动维护，文件随进度更新
-- `cron-progress.md` 是了解织忆当前运行状态的首选入口
-- 任务文件（task-*.md）按阶段命名，反映织忆开发迭代的细粒度任务拆分
-- 随着织忆系统推进，新 task 文件会在此追加

docs/memory-os-7-layer-comparison.md

@@ -1,182 +0,0 @@
-# Memory-OS 7 层记忆架构 与 织忆对比
-
-> 来源：微信公众号文章「7 层记忆架构！给 Agent 装个真正的 "记忆操作系统"」(2026-07-01 提取)
-> GitHub 项目：Memory-OS（3天 648 star），专为 Hermes-Agent 设计的记忆升级系统
-> 提取日期：2026-07-01
-
----
-
-## 一句话定位
-
-Memory-OS 是 Hermes Agent 原生记忆系统之上叠加的 7 层记忆增强层，**不是独立系统**。它改了 Hermes 的 Icarus 插件（pre_llm_call 注入）、加了新存储层（Facts/Qdrant/Wiki）、扩展了 Ground Truth 层级——对 Hermes 有侵入性。
-
-织忆是**完全独立的记忆后端服务**，通过 HTTP + Rust IPC 插件桥接 Hermes。两套系统架构理念不同，但 Memory-OS 的设计值得参考。
-
----
-
-## 7 层对照总表
-
-| 层级 | Memory-OS | 织忆 | 差距 |
-|------|-----------|------|------|
-| **L1 Workspace** | MEMORY.md + USER.md + CREATIVE.md（常驻） | MEMORY.md + USER.md（Hermes 原生） | ❌ 无 CREATIVE.md 隔离 |
-| **L2 Sessions** | FTS5 全文索引 + Icarus 自动注入 | state.db + session_search 工具 | ❌ 无自动预注入（需 Agent 主动调） |
-| **L3 Facts** | 结构化事实 + 信任评分（全新） | 织忆 knowledge graph（语义关系） | ❌ 无信任评分 / fact_feedback 循环 |
-| **L4 Fabric** | LLM 提取跨会话经验卡片（重写 Icarus） | 织忆 episodes 表（206 条） | ⚠️ 织忆有但提取逻辑未 LLM 化 |
-| **L5 Qdrant** | Dense + BM25 双检索 + 4 级降级 | bge-m3 向量 + 语义搜索 | ⚠️ 织忆无 BM25 稀疏 + 无显式降级策略 |
-| **L6 Wiki** | 双定时任务自动策展知识库 | 无此层 | ❌ 织忆无自动知识策展 |
-| **L7 Ground Truth** | 4 级权威层级，强制 Agent 使用 | SOUL.md 3 级 + rulebook.md | ⚠️ 织忆层级少，无"注入记忆优先"prompt |
-
----
-
-## 可借鉴的设计
-
-### 1. 信任评分机制（L3 Facts）
-
-```
-fact_feedback 工具：
-  每次都调用 fact_feedback 反馈有用/无用
-  trust_score 基于 retrieved / helpful 比值计算
-```
-
-**织忆可以做**：给图谱边或 memory 条目加 recall_count / useful_count，算置信度。当前 graph.db 没有这个字段。
-
-### 2. 4 级降级策略（L5 Qdrant）
-
-```
-Level 1 → Dense + BM25 RRF 混合检索
-Level 2 → 仅 Dense 向量检索
-Level 3 → grep 目录下 .md 文件（词法）
-Level 4 → SQLite 搜 lineage 表
-全挂 → fail-open，不阻塞 Agent
-```
-
-**织忆当前**：只走 LanceDB 语义搜索。如果 LanceDB / bge-embed 挂了 → 没有降级备份。
-
-### 3. FTS5 自动注入（L2 Sessions）
-
-Memory-OS 的做法是让 Icarus 在 pre_llm_call 阶段**自动**查相关历史注入系统提示，不等 Agent 调用 session_search。
-
-**织忆当前**：靠 Hermes 原生的 memory_search / memory_graph_navigate 工具，Agent 必须主动调用。
-
-### 4. CREATIVE.md 隔离（L1 Workspace）
-
-```
-MEMORY.md = memory 工具写（环境事实、约定）
-USER.md   = 用户手写（画像、偏好）
-CREATIVE.md = Icarus 写（学习心得、状态）
-```
-
-解决了 memory 工具和 Icarus 双写入冲突。
-
-**织忆当前**：MEMORY.md 同时被 memory 工具和 织忆 commit 写入，有同样冲突风险。
-
-### 5. 强制注入优先级 Prompt（L7）
-
-```
-2. **Injected memory — [qdrant], [fabric], [sessions], [facts]** — 
-   Ground truth for documented knowledge and prior decisions. When 
-   injected memory contradicts your assumptions or training knowledge, 
-   injected memory wins. Never treat a question as novel when the answer 
-   is already in your prompt.
-```
-
-**织忆当前**：SOUL.md 有 Ground Truth 层级但缺少这样的显式注入记忆优先指令。
-
----
-
-## 架构差异
-
-| 维度 | Memory-OS | 织忆 |
-|------|-----------|------|
-| 进程架构 | Hermes 进程内插件（Icarus 钩子） | 独立 Go daemon + Rust sidecar |
-| 依赖度 | 强依赖 Hermes | 框架无关，HTTP API 对接任何 Agent |
-| 存储引擎 | Hermes 原生 SQLite + Qdrant | LanceDB + SQLiteGraphStore |
-| 向量维度 | Qwen3-Embedding-8B 4096维 | bge-m3 1024维 |
-| 注入方式 | pre_llm_call 钩子自动注入 | Agent 主动调用工具触发 |
-| Wiki 能力 | 双定时任务自动策展 | 无 |
-
----
-
-## 实际源码阅读补充（2026-07-01 全量 Clone + 读代码后）
-
-> 已 clone 到 `/tmp/memory-os/` 并 push 到 Gitea `xiaoxue_admin/memory-os`
-> 本次阅读了 hooks.py（1109行，含完整 pre_llm_call 注入链）、tools.py（16个 fabric 工具）、所有 7 层文档
-
-### 核心发现：Icarus 自动注入的实现细节（hooks.py）
-
-Memory-OS 的关键差异在 **Icarus hooks** 的 `pre_llm_call` 注入机制。每轮对话前自动执行：
-
-```python
-# hooks.py 注入链（283-434行）
-pre_llm_call(user_message):
-  ├── _is_social_close(message)?       # 社交关闭检测：ok/thanks/emoji → 不搜索
-  ├── _search_qdrant(query, top_k=2)   # Qdrant 语义检索 → [qdrant]
-  │   ├── embed_query() → dense 向量
-  │   ├── embed_query_sparse() → BM25 稀疏向量
-  │   └── search_with_fallback() → 4级降级
-  ├── _search_sessions(query)          # FTS5 会话搜索 → [sessions]
-  │   ├── FTS5 OR 查询：取用户消息中 ≥4 字符的 token
-  │   ├── 排除当前会话
-  │   └── Python 层去重
-  └── _search_facts(query)             # 结构化事实 FTS5 → [facts]（仅首轮）
-      ├── 查 memory_store.db facts_fts
-      └── 返回 content[:200] + trust_score
-```
-
-**关键模式差异**：
-- Memory-OS：**事件驱动** — 每轮自动注入，Agent 无需操心
-- 织忆：**轮询驱动** — Agent 主动调工具，不调就没有
-
-### 信任评分实现细节（facts 表）
-
-```sql
-CREATE TABLE facts (
-  fact_id INTEGER PRIMARY KEY,
-  content TEXT, category TEXT, entities TEXT,
-  trust_score REAL DEFAULT 0.50,     -- 贝叶斯先验
-  retrieval_count INTEGER DEFAULT 0,
-  helpful_count INTEGER DEFAULT 0,
-  created_at TEXT, last_accessed_at TEXT
-);
-```
-
-**织忆差距**：graph.db 的 edge 表中已有 `weight` 字段，但没有 retrieval_count / helpful_count / trust_score。改 SQLite schema 3 行 SQL 即可解决。
-
-### 4 级降级的实际代码路径
-
-```python
-# context_enhancer.py 中的 search_with_fallback
-def search_with_fallback(dense_vector, sparse_vector, query_text, ...):
-    try:
-        # Level 1: Hybrid (dense + sparse → RRF)
-        return hybrid_search(...)
-    except:
-        try:
-            # Level 2: Dense only
-            return dense_search(...)
-        except:
-            try:
-                # Level 3: Lexical (grep vault/*.md)
-                return lexical_search(query_text)
-            except:
-                try:
-                    # Level 4: SQLite lineage table
-                    return sqlite_search(query_text)
-                except:
-                    return []  # fail-open
-```
-
-织忆当前是 **Level 2 only**（bge-embed vector search）。加 Level 1（BM25）需要 ONNX 模型或 fastembed；加 Level 3/4 简单，直接 grep graph.db 或 LanceDB 的 content 字段。
-
----
-
-| 织忆可能受益的点（优先级排序，2026-07-01 源码更新版）
-
-| 优先级 | 借鉴项 | 实现方式 | 实现成本 | 价值 | 当前状态 |
-|--------|--------|---------|---------|------|---------|
-| P0 | **降级策略** — bge-embed 挂了走 fallback | zhiyid recall handler 加 3 级退化：① LanceDB → ② graph.db LIKE 搜索 → ③ 返回空 | **低**（改 1 个 Go handler） | 高，消除单点故障 | 未实现 |
-| P1 | **自动注入钩子** — pre_llm_call 自动查织忆 | 改 Hermes 织忆插件，加 `on_session_message` 钩子：取消息最后 200 字 → `zhiyi_recall()` → `[织忆]` 注入 system prompt | **中**（改 Python 插件 ~50 行） | 高，减少 Agent 遗 | 未实现 |
-| P2 | **信任评分** — graph 边 / memory 条目加反馈闭环 | ① graph.db edge 表加 `retrieval_count` + `helpful_count` + `trust_score` ② 新增 `POST /api/v1/graph/edge/feedback` 端点 ③ zhiyid 自动调用（类似 Memory-OS fact_feedback） | **中**（SQLite + 1 API + 1 定时任务） | 中，消除矛盾信 | 未实现 |
-| P3 | **CREATIVE.md 隔离** — 防止双写入冲突 | SOUL.md 新增 `CREATIVE.md` 章节，织忆 commit 目标改写 CREATIVE.md 而非 MEMORY.md | **低**（改 skill 工具~10 行） | 中，防冲突 | 未实现 |
-| P4 | **强制注入 Prompt** — SOUL.md 加优先指令 | SOUL.md Ground Truth 加 Level 2：`Injected memory [织忆] wins over assumptions` | **极低**（改 SOUL.md） | 中，减少遗忘 | ⚠️ 已部分实现（4 级但有 gap） |
-| P5 | **Wiki 策展** — 自动知识库 | LLM 双定时任务提取 raw/ → 概念/实体/对比 → 嵌入 Qdrant | **高**（全新子系统） | 低，当前非核心 | 跳过 |

docs/p0-fallback-plan.md

@@ -1,61 +0,0 @@
-# P0: Recall 降级策略 — 织忆 Go daemon
-
-## 目标
-当 bge-embed (8000) 或 Rust IPC sidecar 不可用时，recall 自动降级到 graph.db 关键词搜索，不返回 500 错误。
-
-## 修改文件
-
-### 1. `/tmp/memoryweave/go/internal/governance/graph_sqlite.go`
-新增方法 `FallbackTextSearch(query, namespace, limit)`：
-
-```go
-func (gs *SQLiteGraphStore) FallbackTextSearch(query, namespace string, limit int) []map[string]interface{} {
-    // 1. 从 edge properties 中搜索 content 字段（JSON 内 text 字段）
-    // 2. LIKE '%query%' 模糊匹配 nodes 的 name
-    // 3. 按 pagerank DESC 排序
-    // 4. LIMIT limit
-}
-```
-
-sqlite-go 通过 CGo 操作，参考已有 queryRows 函数（行 1037）。
-类似 SearchNodes（行 865）的模式，但搜索 edges 的 properties 字段。
-
-### 2. `/tmp/memoryweave/go/internal/storage/recall.go`
-在 `RecallPipeline` 结构体新增 `GraphStore` 字段：
-
-```go
-type GraphExpander interface {
-    // ... existing methods
-}
-```
-
-不用改 interface。在 `Recall` 方法末尾（当前行 149 return nil 之前），如果 candidates 为空且 lanceDB 搜索失败，尝试从 GraphStore 的 FallbackTextSearch 获取结果。
-
-### 3. `/tmp/memoryweave/go/internal/api/routes/core.go`
-在 `Recall` handler（行 209-293）中，当 `a.Pipeline.Recall()` 返回 err 时（行 240），不直接 500，而是调用 graph store 的 fallback 搜索：
-
-```go
-if err != nil {
-    // Fallback: graph.db keyword search
-    fallbackResults := a.GraphStore.FallbackTextSearch(req.Query, req.Namespace, req.Limit)
-    if len(fallbackResults) > 0 {
-        // Convert fallback results to RecallResult format
-        results = convertFallbackResults(fallbackResults)
-        // return with 200 + warning header
-    } else {
-        respondError(w, 500, "recall failed: "+err.Error())
-        return
-    }
-}
-```
-
-## 验证方法
-```bash
-# 正常状态能搜到
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" \
-  -d '{"query":"小唯","top_k":3}' \
-  http://localhost:7821/api/v1/recall | python -c "import json,sys;d=json.load(sys.stdin);print(f'count: {d.get(\"count\",0)}')"
-
-# 模拟 bge-embed 挂了
-# curl 应该仍返回结果（从 graph.db 关键词搜索）
-```

docs/p1-autoinject-plan.md

@@ -1,83 +0,0 @@
-# P1: 自动注入钩子 — 织忆 Hermes 插件
-
-## 目标
-增强 Hermes 织忆插件的 prefetch/queue_prefetch，实现：
-1. queue_prefetch 缓存下一轮记忆（异步预取）
-2. 社交关闭检测（skip trivial messages）
-3. 新增 [织忆] 标记注入格式，与 hermes 原生记忆区分
-4. 更好的话题重叠检测（避免同一轮注入重复上下文）
-
-## 修改文件
-
-### `~/.hermes/hermes-agent/plugins/memory/zhiyi/__init__.py`
-
-#### 1. 新增社交关闭检测（参考 Memory-OS hooks.py:251-268）
-```python
-_SOCIAL_CLOSERS = frozenset({
-    "ok", "好的", "👍", "👌", "✅", "谢谢", "感谢", "知道了",
-    "明白", "嗯", "好", "行", "yes", "yep", "thanks", "thx",
-    "no", "不用", "没事", "可以", "done", "完成",
-})
-
-def _is_social_close(text: str) -> bool:
-    text = text.strip().lower()
-    if text in _SOCIAL_CLOSERS:
-        return True
-    if len(text) < 6 and not any(c in text for c in "://.@#$_?"):
-        return True
-    return False
-```
-
-#### 2. 实现 queue_prefetch（原为 pass）
-```python
-def queue_prefetch(self, query: str, *, session_id: str = "") -> None:
-    """异步预取：本轮对话结束后立即查询织忆，下一轮 prefetch 直接返回缓存。"""
-    if not self._client or not query or len(query.strip()) < 2:
-        return
-    if _is_social_close(query):
-        return
-    # 后台线程查询并缓存
-    def _async_prefetch():
-        results = self._client.recall(query.strip(), top_k=3)
-        notes = self._client.search_notes(query.strip(), max_hops=2, max_notes=3)
-        with self._prefetch_lock:
-            self._prefetch_cache["queue"] = {
-                "results": results,
-                "notes": notes,
-                "timestamp": time.time()
-            }
-    threading.Thread(target=_async_prefetch, daemon=True).start()
-```
-
-#### 3. 增强 prefetch 方法
-```python
-# 在 prefetch 入口处：
-if _is_social_close(query):
-    return ""  # 关闭消息不触发预取
-
-# 优先从 queue_prefetch 缓存取
-with self._prefetch_lock:
-    queued = self._prefetch_cache.pop("queue", None)
-    if queued and (time.time() - queued["timestamp"]) < 30:
-        # 用缓存结果
-        pass
-    
-# 输出格式改成带 [织忆] 标记
-blocks = ["[织忆 Memory — relevant past context]"]
-for r in results:
-    blocks.append(f"  [{score:.2f}][{cat}] {content[:500]}")
-```
-
-## 验证方法
-```bash
-cd ~/.hermes/hermes-agent && python3 -c "
-from plugins.memory.zhiyi import HermesZhiYiMemoryProvider
-p = HermesZhiYiMemoryProvider()
-# 测试 prefetch
-result = p.prefetch('织忆记忆系统架构', session_id='test')
-print('prefetch result:', result[:200] if result else 'empty')
-# 测试 social closer
-result2 = p.prefetch('好的', session_id='test')
-print('social closer prefetch:', repr(result2))
-"
-```

docs/p2-trustscore-plan.md

@@ -1,69 +0,0 @@
-# P2: 信任评分 — 织忆 Go daemon
-
-## 目标
-给 graph.db 的 edges 表加信任评分字段，新增反馈 API 端点。
-
-## 修改文件
-
-### 1. `/tmp/memoryweave/go/internal/governance/graph_sqlite.go`
-
-#### a) Upgrade SQL 迁移（在 migrate() 中追加）
-```sql
-ALTER TABLE graph_edges ADD COLUMN trust_score REAL DEFAULT 0.5;
-ALTER TABLE graph_edges ADD COLUMN retrieval_count INTEGER DEFAULT 0;
-ALTER TABLE graph_edges ADD COLUMN helpful_count INTEGER DEFAULT 0;
-```
-注意：ALTER TABLE ADD COLUMN 要先检查列是否存在，用 sqlite3 的 `PRAGMA table_info(graph_edges)` 检查。
-
-#### b) 新增方法
-```go
-// AddEdgeFeedback 记录边反馈
-func (gs *SQLiteGraphStore) AddEdgeFeedback(edgeID string, helpful bool) error
-// 实现：UPDATE graph_edges SET helpful_count = helpful_count + 1 WHERE id = ?
-// 如果不是 helpful: UPDATE graph_edges SET retrieval_count = retrieval_count + 1 WHERE id = ?
-
-// UpdateEdgeTrustScores 批量更新信任评分（定时或触发）
-func (gs *SQLiteGraphStore) UpdateEdgeTrustScores() error
-// 实现：UPDATE graph_edges SET trust_score = 
-//   CASE 
-//     WHEN retrieval_count > 0 THEN CAST(helpful_count AS REAL) / retrieval_count
-//     ELSE 0.5 
-//   END
-
-// IncrementEdgeRetrieval 递增边的检索计数（在 ExpandFromResults 里调用）
-func (gs *SQLiteGraphStore) IncrementEdgeRetrieval(edgeID string) error
-```
-
-#### c) 在 ExpandFromResults（行 679-733）中，每条被检索的边调用 IncrementEdgeRetrieval
-
-### 2. `/tmp/memoryweave/go/internal/api/routes/core.go`
-新增端点：
-
-```go
-// POST /api/v1/graph/edge/feedback
-func (a *API) EdgeFeedback(w http.ResponseWriter, r *http.Request) {
-    // body: { edge_id: string, helpful: bool }
-    // 调用 a.GraphStore.AddEdgeFeedback(edgeID, helpful)
-}
-```
-
-### 3. `/tmp/memoryweave/go/internal/api/server.go`
-注册新路由：
-```go
-mux.HandleFunc("/api/v1/graph/edge/feedback", api.EdgeFeedback)
-```
-
-### 4. `/tmp/memoryweave/go/internal/api/routes/core.go`
-在 Recall handler 中，当结果返回时（行 292），遍历每条结果的 edge ID，递增 retrieval_count。
-
-## 验证方法
-```bash
-# 提交反馈
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" \
-  -H "Content-Type: application/json" \
-  -d '{"edge_id":"e_xxx","helpful":true}' \
-  http://localhost:7821/api/v1/graph/edge/feedback
-
-# 验证 trust_score 更新
-sqlite3 /var/lib/memoryweave/graph.db "SELECT id, trust_score, retrieval_count, helpful_count FROM graph_edges LIMIT 5"
-```

docs/p3-creative-plan.md

@@ -1,44 +0,0 @@
-# P3: CREATIVE.md 隔离 — 防止双写入冲突
-
-## 问题
-MEMORY.md 同时被 `memory` 工具（写环境事实/约定）和织忆（写记忆/经验）写入，可能导致 `§` 分隔符污染和数据混乱。
-
-## 方案（参考 Memory-OS: 把 Icarus 写目标从 MEMORY.md 拆到 CREATIVE.md）
-
-1. 在 `~/.hermes/` 下创建 `CREATIVE.md` 文件（初始内容为空，带标记头）
-2. 修改 Hermes 织忆插件的 `sync_turn` 方法：将记忆写出目标从 MEMORY.md 改为 CREATIVE.md
-3. 确保 Hermes 的 `system_prompt_block()` 返回 `CREATIVE.md` 的内容（如果文件存在）
-4. 当前 `sync_turn` 使用的是 Hermes 原生 memory 工具写入 → 需要确认是直接写文件还是通过工具
-
-## 具体文件
-
-### `~/.hermes/CREATIVE.md` — 创建
-```markdown
-# CREATIVE.md — 织忆(A06)工作记忆与学习状态
-> 由 Hermes 织忆插件自动管理，`memory` 工具请写入 MEMORY.md
-> 创建日期：2026-07-02
-
-<!-- 织忆自动写入区 — 请勿手动编辑 -->
-```
-
-### `~/.hermes/hermes-agent/plugins/memory/zhiyi/__init__.py` — 修改 sync_turn
-当前 sync_turn（~391行附近）把对话写入织忆后端（/commit API），同时可能也写 MEMORY.md。
-需要确认：插件代码是否直接写 MEMORY.md？如果没写，那 P3 的动作为：
-1. 在 `system_prompt_block()` 方法中：检测并返回 CREATIVE.md 内容
-2. 织忆本身通过 /commit 存储到 LanceDB，和 MEMORY.md 无关 → 没有直接冲突
-3. 所以 P3 = 创建 CREATIVE.md + 让 system_prompt_block 使用它 + 说明织忆的专用存储不在 MEMORY.md
-
-## 验证
-```bash
-# CREATIVE.md 文件存在
-ls -la ~/.hermes/CREATIVE.md
-# 插件 system_prompt_block 返回正确
-cd ~/.hermes/hermes-agent && python3 -c "
-from plugins.memory.zhiyi import HermesZhiYiMemoryProvider
-p = HermesZhiYiMemoryProvider()
-p.initialize(session_id='test')
-block = p.system_prompt_block()
-print('CREATIVE.md in prompt:', 'CREATIVE.md' in block or '工作记忆' in block)
-print(f'block length: {len(block)}')
-"
-```

docs/p4-prompt-plan.md

@@ -1,51 +0,0 @@
-# P4: 强制注入 Prompt — SOUL.md Ground Truth 扩展
-
-## 问题
-SOUL.md 虽然有 4 级 Ground Truth 层级，但缺少显式的"注入记忆优先"指令。
-当 [织忆 Memory] 被注入系统提示时，Agent 可能视其为"建议"而非"权威"，
-导致 Agent 仍去调 memory_search / session_search 重新发现已经有的信息。
-
-## 方案（参考 Memory-OS Layer 7 的做法）
-
-在 `~/.hermes/SOUL.md` 中补充：
-
-### 1. Ground Truth 层级中显式加入"注入记忆"级别
-```markdown
-## Ground Truth
-
-Authoritative sources, in priority order:
-
-1. **Terminal output** — stdout, stderr, exit codes. Ground truth for current system state.
-2. **Injected memory — [织忆], [fabric], [qdrant], [sessions]** — Ground truth for documented knowledge and prior decisions.
-   When injected memory contradicts your assumptions or training knowledge, injected memory wins.
-   Never treat a question as novel when the answer is already in your prompt.
-3. **Official documentation** — man pages, --help, upstream docs. Authoritative for APIs and configs.
-4. **Training knowledge** — reference only. Always verify against sources 1-3.
-```
-
-### 2. 上下文注入约定章节
-```markdown
-## Context injection convention
-
-When context is injected into the system prompt, it is labeled by source:
-- [织忆 Memory] — from ZhiYi semantic recall (+ graph navigation)
-- [织忆 Graph] — from ZhiYi knowledge graph (Obsidian notes)
-
-Injected memory takes priority level 2 in Ground Truth. This means: you
-already know this. Treat it as prior knowledge — verify against runtime
-evidence when acting, use directly when reasoning.
-```
-
-### 3. 记忆反馈规则
-```markdown
-**Memory feedback rule:** When you retrieve memory from 织忆 (via memory_search,
-memory_graph_navigate, or prefetch injection) and reference it in your response,
-you should consider its trust_score. Higher trust_score = more reliable facts.
-Use memory_feedback to mark useful/unuseful results — this trains the trust scoring system.
-```
-
-## 验证
-```bash
-grep -A 20 "## Ground Truth" ~/.hermes/SOUL.md | head -25
-grep -A 30 "## Context injection convention" ~/.hermes/SOUL.md | head -15
-```

docs/p5-wiki-curation-plan.md

@@ -1,77 +0,0 @@
-# P5: Wiki 策展管线 — 自动知识库
-
-## 问题
-织忆能存储和检索记忆，但没有"知识库"的概念：将外部文档（.md 文章、技术笔记、项目文档）
-自动提取为结构化知识条目，写入织忆系统供后续 recall 搜索。
-
-## 方案（参考 Memory-OS Layer 5+6，适配织忆架构）
-
-Memory-OS 用 Wiki Agent（LLM 提取概念/实体/对比）+ Continuous Ingest（嵌入 Qdrant）。
-织忆的替代方案：Python 脚本扫描 Obsidian Vault → LLM 提取知识点 → 通过 /commit API 写入织忆。
-
-## 实现
-
-### 新增文件: `scripts/wiki_curator.py`
-
-```python
-#!/usr/bin/env python3
-"""
-Wiki Curator — 自动知识策展管线
-扫描 Obsidian vault 中的 .md 文件，用 LLM 提取知识点，通过织忆 API 存入结构性记忆。
-
-流程:
-1. 扫描 ~/mc/小唯/ 和 ~/obsidian/ 中的 .md 文件（排除缓存/临时文件）
-2. SHA-256 diff 检测（只处理新增/修改的文件）
-3. LLM 提取：
-   - 概念（concept）：什么是 X？
-   - 实体（entity）：X 的属性/参数/配置
-   - 关系（relation）：X 和 Y 的关系
-4. 通过织忆 /commit API 写入 memories（category='wiki'）
-5. 更新状态文件（记录已处理的文件哈希）
-"""
-
-# 配置
-WIKI_DIRS = [
-    "~/mc/小唯/",           # 织忆设计文档/技术笔记
-    "~/mc/牧尘/",           # 系统配置/命令记录
-    # 可根据需要扩展
-]
-ZHIYI_API = "http://localhost:7821"
-ZHIYI_KEY = "zhiyi-dev-key-2026"
-STATE_FILE = "~/.hermes/wiki_curator_state.json"
-```
-
-### 处理逻辑
-
-对每个新/修改的文件：
-1. 读取内容，过滤掉过短（<500字）或明显非知识性的文件
-2. 调用 LLM（Hermes 的模型或 NewAPI）提取：
-   ```json
-   {
-     "concepts": [{"name": "X", "summary": "...", "details": "..."}],
-     "entities": [{"name": "Y", "attributes": {...}}],
-     "relations": [{"source": "X", "relation": "uses", "target": "Y"}]
-   }
-   ```
-3. 对每个提取的概念/实体，通过织忆 /commit API 写入
-4. 对每个关系，通过织忆 /api/v1/graph/edge API 写入
-
-### 定时任务
-
-创建 cronjob 每周运行两次（周一/周四凌晨3点）：
-```bash
-hermes cron add "织忆 Wiki 策展" --schedule "0 3 * * 1,4" \
-  --prompt "执行 wiki_curator.py 扫描检查" \
-  --script ~/.hermes/scripts/wiki_curator.py
-```
-
-## 验证
-```bash
-# 手动运行
-python3 ~/.hermes/scripts/wiki_curator.py --dry-run
-
-# 验证织忆端已有 wiki 类记忆
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" \
-  -d '{"query":"织忆设计","top_k":5}' \
-  http://localhost:7821/api/v1/recall
-```

docs/plans/2026-10-06-distill-quality-pipeline-fix.md

@@ -1,276 +0,0 @@
-# 织忆蒸馏质量链路修复方案
-
-> **面向实现者**：每任务 2~5 分钟粒度，含精确路径、行号、完整代码、验证命令与期望输出。
-> **日期**：2026-10-06 ｜ **状态**：待拍板 ｜ **拟定**：小怡
-
----
-
-## 一、目标
-
-切断这条因果链（本次排查发现的真实病灶）：
-
-```
-评分闸门失效（prompt 示例被模型原样 echo）
-        ↓
-只剩「文本长度」一道闸门在扛
-        ↓
-提取器为过闸门 → 给短规则追加固定话术（enrich）
-        ↓
-伪造内容进入长期记忆库（已污染 6 条，含跨技能串味）
-```
-
-并顺带修掉 2 个次生 bug。
-
-**注意**：上一轮我曾建议「蒸馏入口拒收规则块」—— **该建议作废**。证据 E4 表明「规则→episode→蒸馏」是**有意设计且工作正常**的流水线，拒收会砸掉整条技能规则入库链路。
-
-## 二、架构
-
-三处独立改动，互不阻塞：
-
-| 层 | 文件 | 改什么 |
-|---|---|---|
-| 蒸馏（Go） | `go/internal/distill/engine.go` | 去 echo 源 + 加 echo 检测 + 影子模式 |
-| 提取（Python） | `~/.hermes/scripts/skill_rule_extractor_v2.py` | 停用伪造式扩写 |
-| 遗忘（Go） | `go/internal/api/routes/admin.go` · `go/internal/storage/lancedb_ipc.go` · `go/internal/api/server.go` | 空 id 防御 + 计数修正 |
-
-## 三、证据链（为什么这么改）
-
-| # | 事实 | 证据（可复现） |
-|---|---|---|
-| E1 | 评分是 prompt 示例复读 | `engine.go:534` 写死示例 `"is":0.8,"su":0.7,"pa":0.6,"vd":0.9,"ru":0.7`。实测：换内容分数不变；把示例数字改成 0.1~0.5，输出跟着变成 0.3~0.7 |
-| E2 | 评分门槛永不触发 | `engine.go:417` 判据 `overall<0.7 && score.VD<0.8`；echo 值按 `engine.go:89` 权重算得 `overall=0.755`，恒 ≥0.7 |
-| E3 | 扩写话术已入记忆库 | `memories` 表命中 **6 条**，含 3 条纯话术本身、1 条跨技能串味（`hermes-soul-maintenance｜修改纪律：…rclone lsf`） |
-| E4 | 流水线本身是好的 | 台账按规则指纹去重：**入库 1539 / 被丢 0 / 在途 60 = 100% 收敛**（`~/.hermes/skill_rules_ingest_ledger.jsonl`） |
-| E5 | 空 id 根因在数据层 | `memories` 表有 **2 行** id/content/source 全空 ⇒ 命中「<30 字碎片快速道」⇒ `SoftDelete("")` ⇒ Rust `rust/src/main.rs:331` 拒绝 |
-
-## 四、施工铁律
-
-1. **不许 python 直连写 LanceDB**：zhiyid 运行期直连写 = 双写源（与 state.db 同类事故）。**所有删除走 HTTP API**。
-2. **P0-1/P0-2 必须影子模式先行**：修好 echo 会**激活一个此前从不触发的闸门**，可能造成批量丢弃。先 log-only 观察，再决定是否真拦。
-3. **改前备份、改后复验**：Go 改动过 `go vet` + 全量测试；Python 改动跑断言。
-
----
-
-## 五、任务清单
-
-### P0-3 停用「伪造式扩写」〔建议先做，止血〕
-
-**文件**：`/home/muc/.hermes/scripts/skill_rule_extractor_v2.py:407-409`
-
-**Step 1** 删掉追加固定话术的分支
-
-旧：
-```python
-    if len(r["rule"]) < 45:
-        body += (" ｜执行时须落到具体命令与路径（如 hermes kanban list、pgrep -f、"
-                 "~/.hermes/scripts/、rclone lsf），并在汇报里贴出原始输出片段作为证据。")
-```
-
-新：
-```python
-    # 🔴 禁止追加与规则无关的固定话术（2026-10-06）：那会伪造出技能从未声明过的"事实"，
-    #    已污染 memories 6 条（含跨技能串味）。短规则宁可被丢，也不许编。
-    #    真实扩写只允许用规则自带字段（why/anti/scope，已在上方拼入）。
-```
-
-**Step 2** 验证（必须证明它不再产出那句话）
-```bash
-python3 -c "
-import importlib.util,pathlib
-spec=importlib.util.spec_from_file_location('e', pathlib.Path.home()/'.hermes/scripts/skill_rule_extractor_v2.py')
-m=importlib.util.module_from_spec(spec); spec.loader.exec_module(m)
-out=m.enrich({'skill':'x','section':'y','rule':'短规则','why':'因为所以','anti':'','scope':''})
-print(out)
-assert '执行时须落到具体命令与路径' not in out, '❌ 伪造话术仍在'
-print('✅ 已停用伪造扩写')
-"
-```
-期望：打印 `✅ 已停用伪造扩写`。
-
-**Step 3** 记录代价：改完重跑一轮 `skill_rules_sync.py`，把台账 `landed` 变化作为**代价数据**上报（短规则入库率会下降，这是可接受的真话）。
-
----
-
-### P0-4 清理已污染的 6 条记忆〔建议先做，止血〕
-
-**🔴 走 HTTP API，不许直连写库。**
-
-**Step 1** 取 id（已取得，见下）→ 先 dry-run 看影响面
-**Step 2** 逐个软删，`reason` 用 `polluted_expansion_20261006`
-
-```
-mem_1791262758250672496  收到牧尘任务…｜依据…｜适用…｜执行时须落到具体命令与路径（…）
-mem_1791261603417879613  适用：cron 连续失败诊断 ｜执行时须落到…
-mem_1791267692697346820  hermes-soul-maintenance｜修改纪律：执行时须落到…   ← 跨技能串味
-mem_1791215971324172233  执行时须落到具体命令与路径（…）                  ← 纯话术
-mem_1791215338803223776  执行时须落到具体命令与路径（…）                  ← 纯话术
-mem_1791270196923533388  使用 --move-slide 时 ｜执行时须落到…              ← 无关规则被串味
-```
-
-**Step 3** 复验：同脚本再查一次，`执行时须落到具体命令与路径` 命中 **0**。
-
----
-
-### P0-1 去掉评分 prompt 的 echo 源
-
-**文件**：`go/internal/distill/engine.go:533-536`
-
-**Step 1** 把「填好的示例」换成「类型骨架 + 显式禁令」
-
-旧：
-```
-输出格式（严格JSON）:
-{"facts": ["独立事实1", "独立事实2"], "decisions": ["决定1"], "conclusions": ["结论1"], "actions_taken": ["行动1"], "open_questions": ["问题1"], "entities": ["entity1", "entity2"], "is": 0.8, "su": 0.7, "pa": 0.6, "vd": 0.9, "ru": 0.7}
-
-评分说明：is/su/pa/vd/ru 是 0.0 到 1.0 之间的浮点数（越高越好），不要用 0-10 整数。
-```
-
-新：
-```
-输出格式（严格JSON）:
-{"facts": ["..."], "decisions": ["..."], "conclusions": ["..."], "actions_taken": ["..."], "open_questions": ["..."], "entities": ["..."], "is": <小数>, "su": <小数>, "pa": <小数>, "vd": <小数>, "ru": <小数>}
-
-评分说明：is/su/pa/vd/ru 必须是 0.0~1.0 之间的浮点数（越高越好），不得用 0-10 整数。
-🔴 上例中的 <小数> 是类型占位符，不是数值。必须依据**本次内容**独立打分；沿用任何示例数值都算错误答案。
-```
-
-**Step 2** 验证
-```bash
-cd /home/muc/src/memoryweave/go && go vet ./internal/distill/ && go test ./internal/distill/ -count=1
-```
-期望：全 PASS。
-
-**Step 3** liveprobe 实证（沿用 `quality_liveprobe_test.go` 的手法）
-```bash
-go test ./internal/distill/ -tags liveprobe -run TestLiveScoreNotEcho -v -count=1
-```
-期望：6 条不同内容 → **分数不再全部相同**（≥3 种不同向量）。
-
----
-
-### P0-2 加「echo 检测 + 影子模式」
-
-**Step 1** 新增检测（`engine.go`，用现成评分结构，见 `engine.go:65-80`）
-
-```go
-// echoScoreVectors 是 prompt 历史版本里出现过的示例评分向量。
-// 模型输出与任一向量完全相同 ⇒ 判定为「照抄示例」，评分不可信。
-var echoScoreVectors = [][5]float64{
-	{0.8, 0.7, 0.6, 0.9, 0.7},
-}
-
-// IsEchoScore 判断评分是否在照抄 prompt 示例。
-func IsEchoScore(s Score5D) bool {
-	for _, v := range echoScoreVectors {
-		if s.IS == v[0] && s.SU == v[1] && s.PA == v[2] && s.VD == v[3] && s.RU == v[4] {
-			return true
-		}
-	}
-	return false
-}
-```
-
-**Step 2** 影子开关（默认开=只记录不拦）
-
-```go
-// 默认影子模式：只记录「本该被丢」的样本，不真的丢。
-// 修好 echo 会激活一个此前从不触发的闸门，必须先观察再开拦。
-var scoreShadowMode = os.Getenv("ZHIYI_SCORE_SHADOW") != "0"
-```
-
-在 `engine.go:417` 判据处：
-```go
-	if overall < 0.7 && score.VD < 0.8 {
-		if scoreShadowMode {
-			log.Printf("[distill][SHADOW] would-drop episode=%s overall=%.3f vd=%.2f echo=%v",
-				input.EpisodeID, overall, score.VD, IsEchoScore(score))
-		} else {
-			// …原丢弃逻辑保持不变…
-		}
-	}
-```
-
-**Step 3** 验证（**阴性对照是硬要求**）
-```bash
-go test ./internal/distill/ -run TestIsEchoScore -v -count=1
-```
-必须含：正例 `{0.8,0.7,0.6,0.9,0.7}` → `true`；负例 `{0.8,0.7,0.6,0.9,0.8}` → `false`。
-> 量具铁律：新量具先用正例证明它会报阳性，再用负例证明它不滥报。
-
-**Step 4** 观察期：影子模式跑 ≥3 天，统计 `[SHADOW] would-drop` 条数占总量比，再决定是否 `ZHIYI_SCORE_SHADOW=0` 开真拦。
-
----
-
-### P1-1 修遗忘路径的空 id 崩溃 + 计数 bug
-
-**Step 1** `go/internal/storage/lancedb_ipc.go:584` 入口挡空 id
-```go
-func (rc *RustLanceDBClient) SoftDelete(id, reason string) error {
-	if strings.TrimSpace(id) == "" {
-		return fmt.Errorf("SoftDelete: empty id (reason=%s)", reason)
-	}
-	…
-```
-
-**Step 2** 两个调用点加守卫
-- `go/internal/api/routes/admin.go:86-92`：加 `if strVal(mem["id"]) == "" { skippedNoID++; continue }`
-- `go/internal/api/server.go:1641`：`if id, ok := m["id"].(string); ok && id != "" {`
-  > ⚠️ 漏洞点：**空串能通过 `ok` 断言**，原写法拦不住。
-
-**Step 3** 修计数 bug（`admin.go:90`）—— 现在 `SoftDelete` 失败**照样** `forgotten++`
-```go
-		if err := aa.LanceDB.SoftDelete(id, "auto_forget_fragment"); err != nil {
-			log.Printf("[softdelete] failed id=%q: %v", id, err)
-			continue          // 失败不计数
-		}
-		forgotten++
-```
-
-**Step 4** 那 2 行垃圾记录（id/content/source 全空）：**无法用 id 软删**（id 为空）⇒ 需要 zhiyid 侧一次性维护（加 `/api/v1/admin/purge-invalid` 端点，或 Rust 侧按 `id == ""` 条件清理）。**本项单独拍板，不许手工直连删。**
-
-**Step 5** 验证
-```bash
-journalctl --user -u zhiyid --since "10 min ago" | grep -c 'id required'
-```
-期望：触发一次 forget 后仍为 **0**。
-
----
-
-### P2 根治方向〔观察后再定，本次不实施〕
-
-**问题**：`IsQualityFact` 用「≥20 字 + 含实体/动词」判「像不像事实」，但技能规则天然是短句 ⇒ 规则块只能靠"拉长"过关。**根子是闸门与内容类型不匹配。**
-
-**方向**：给规则块开专用通道 —— 蒸馏入口识别 `^\[规则:` 前缀，**整条规则作为一条 fact**（不交给 2B 剁碎）。收益：规则不再需要扩写作弊、碎片不再产生、评分闸门可以专心管真对话。
-**风险**：改动 `distillOne` 的 fact 组装，影响面大 ⇒ 先用 P0 的影子数据说话再定。
-
----
-
-## 六、验收总表
-
-| 任务 | 判据 | 复验方式 |
-|---|---|---|
-| P0-3 | 不再产生伪造话术 | `enrich()` 输出断言不含该句 |
-| P0-4 | 污染清零 | 同脚本复查命中 0 |
-| P0-1 | 分数不再恒定 | liveprobe：6 条不同内容 → ≥3 种分数向量 |
-| P0-2 | echo 可检出 | 单测正例 true / 负例 false |
-| P1-1 | 日志无 `id required`；计数与实际一致 | `journalctl \| grep -c` = 0；`forgotten` == 真删数 |
-
-## 七、顺序与依赖
-
-```
-P0-3（停伪造）──┐
-P0-4（清污染）──┴─→ 止血完成
-                     ↓
-P0-1（去 echo）→ P0-2（影子观察 ≥3 天）→ 决定是否开真拦 → P2 评估
-
-P1-1（防御+计数）独立，随时可做
-```
-
-**建议**：先做 **P0-3 + P0-4**（停止新增污染 + 清掉已有污染，改动小、可逆），再做 **P0-1/P0-2**（治本，但需观察期），**P1-1** 穿插做。
-
-## 八、明确不做的事
-
-- ❌ 不在蒸馏入口拒收规则块（会砸掉技能规则入库链路，见 E4）
-- ❌ 不直接改 LanceDB（双写源风险）
-- ❌ 不在影子数据出来前打开真拦（可能批量丢弃）
-- ❌ 不动 `graph_auto.go` 等无关文件（只改本方案列出的项）

docs/progress/cron-progress.md

@@ -1,73 +0,0 @@
-# 织忆 (MemoryWeave) 进度追踪
-
-> 版本：v2.6
-> 最后更新：2026-05-24
-
-## 当前阶段
-
-**Phase 1.1 Auto-Distill Engine** — 🟢 已完成
-
-## 项目信息
-
-| 项目 | 路径/地址 |
-|------|----------|
-| **代码仓库** | `~/projects/zhiyi/` |
-| **Gitea** | http://192.168.123.11:3000/xiaoxue_admin/zhiyi |
-| **设计文档** | `~/mc/小唯/07-Wiki/concepts/织忆(MemoryWeave)-v2.6-完整定稿.md` |
-| **实施计划** | `~/mc/小唯/07-Wiki/concepts/织忆(MemoryWeave)-v2.6-实施计划.md` |
-
-## 进度总览
-
-| 阶段 | 状态 | 说明 |
-|------|------|------|
-| Phase 1.1 Auto-Distill Engine | 🟢 已完成 | 2026-05-25 完整版 |
-| Phase 1.2 L0→L1 JSONL 分片 | 🟢 已完成 | 2026-05-25 |
-| Phase 1.3 基础 API | 🟢 已完成 | 2026-05-25 |
-|| Phase 2.1 知识图谱 | 🟢 已完成 | 并行 — NetworkX图构建/查询/懒加载 |
-| Phase 2.2 Peer Representation | 🟢 已完成 | 并行 — 三步推理/线性衰减/Tier分层 |
-|| Phase 2.3 经验模板 | 🟢 已完成 | 2026-05-25 — Pattern→Template 生成+存储+API |
-| Phase 3 SDK 集成 | 🟢 已完成 | 2026-05-25 — Python客户端(ZhiYiSync/ZhiYiClient)+skill接入 |
-| Phase 3 多实例同步 | 🟢 已完成 | 2026-05-25 — AppendLog+MemoryCRDT+同步API |
-
-## 下一步任务
-
-**🎉 所有计划阶段已完成！**
-
-已完成优化：
-- ✅ Phase 4: 性能优化（SQLite图存储 + Embedding缓存）
-- ✅ venv环境修复（pip依赖重建）
-- ✅ 端到端API测试（全部endpoint通）
-- ✅ Recall修复（episodes+distilled双类目、多月扫描、关键词召回正常）
-- ✅ Recall语义搜索（TF-IDF + 关键词兜底，余弦相似度排序）
-- ✅ 完整pipeline（commit→同步蒸馏→distilled→recall立即可用）
-
-可选优化方向：
-- Phase 5: 分布式部署（多实例 + 负载均衡）
-- Recall功能完善（embedding集成）
-- 项目提交到Gitea仓库
-
-## 最近完成
-
-- ✅ Phase 1.1 完成 (2026-05-25 完整版): 数据模型+队列+硬规则+评估+合并+冲突检测+主引擎
-- ✅ Phase 2.3 完成 (2026-05-25): Pattern→Template生成+存储+API
-- ✅ Phase 3.1 完成 (2026-05-25): Python SDK (ZhiYiSync/ZhiYiClient) + zhiyi-memory skill
-- ✅ Phase 3.2 完成 (2026-05-25): AppendLog + MemoryCRDT + sync API
-- ✅ Phase 4 完成 (2026-05-25): SQLite图存储 + Embedding缓存
-- ✅ Phase 1.2 完成 (2026-05-25): JSONL分片+墓碑机制
-- ✅ Phase 1.3 完成 (2026-05-25): FastAPI 服务(/commit/recall/conflicts/feedback/admin)
-- ✅ 项目目录结构创建 (`~/projects/zhiyi/`)
-- ✅ Gitea 仓库创建
-- ✅ Git 初始化 + 首次提交
-- ✅ 参考项目同步到本地 (9个)
-- ✅ AGENTS.md 工作流程写死
-- ✅ zhiyi-dev skill 创建
-- ✅ 设计文档 v2.6 完成
-
-## 待解决问题
-
-无
-
----
-
-*每次 session 结束时更新此文件*
-*定时任务每2小时检查一次进度*

docs/progress/task-phase1-1-models-queue.md

@@ -1,183 +0,0 @@
-## OpenCode 任务 - Phase 1.1 数据模型 + 持久化队列
-
-**日期**: 2026-05-24
-**项目**: 织忆 (MemoryWeave)
-**代码仓库**: ~/projects/zhiyi/
-
----
-
-### 背景
-
-织忆是独立记忆服务，把对话日志蒸馏成结构化记忆。此任务是 Phase 1.1 的核心入口。
-
----
-
-### 具体任务
-
-#### 任务 1: Episode 模型
-文件: `src/models/episode.py`
-
-```python
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Optional
-
-@dataclass
-class Episode:
-    """原始记忆单元 — 对话日志、任务记录等"""
-    id: str                          # UUID
-    timestamp: datetime              # 创建时间
-    content: str                     # 原始内容
-    entities: list[str] = field(default_factory=list)   # 实体列表
-    facts: list[str] = field(default_factory=list)     # 事实列表
-    metadata: dict = field(default_factory=dict)       # 元数据
-    source: str = "hermes"           # 来源: hermes/openclaw/manual
-```
-
-**要求**:
-- dataclass 风格
-- 有 `to_dict()` / `from_dict()` 序列化方法
-- UUID 生成用 `uuid.uuid4()`
-
----
-
-#### 任务 2: Distilled 模型
-文件: `src/models/distilled.py`
-
-```python
-from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Optional
-
-@dataclass
-class Distilled:
-    """蒸馏后的结构化记忆"""
-    id: str
-    episode_id: str                  # 来源 Episode ID
-    type: str                        # "decision" | "request" | "fact" | "pattern"
-    summary: str                     # 摘要
-    entities: list[str] = field(default_factory=list)
-    facts: list[str] = field(default_factory=list)
-    confidence: float = 0.5          # 置信度 0-1
-    status: str = "pending"          # "pending" | "validated" | "deprecated"
-    importance: int = 0              # 重要性 0-5，>=3 永不衰减
-    created_at: datetime = field(default_factory=datetime.now)
-    updated_at: datetime = field(default_factory=datetime.now)
-```
-
-**要求**:
-- 同上，有序列化方法
-- `status` 可选值用常量或 enum
-
----
-
-#### 任务 3: 持久化队列
-文件: `src/distill/queue.py`
-
-```python
-import sqlite3
-import json
-from pathlib import Path
-from datetime import datetime
-from typing import Optional
-from ..models.episode import Episode
-
-class PersistenceQueue:
-    """SQLite 持久化队列 — 入队/出队/持久化"""
-
-    def __init__(self, db_path: str = "zhiyi.db"):
-        self.db_path = db_path
-        self.conn = sqlite3.connect(db_path)
-        self._init_db()
-
-    def _init_db(self):
-        """初始化表结构"""
-        self.conn.execute("""
-            CREATE TABLE IF NOT EXISTS episode_queue (
-                id TEXT PRIMARY KEY,
-                data TEXT NOT NULL,
-                enqueued_at TEXT NOT NULL,
-                dequeued_at TEXT,
-                status TEXT DEFAULT 'pending'
-            )
-        """)
-        self.conn.commit()
-
-    def enqueue(self, episode: Episode) -> bool:
-        """入队，返回是否成功"""
-
-    def dequeue(self) -> Optional[Episode]:
-        """出队，返回 Episode 或 None"""
-
-    def peek(self) -> Optional[Episode]:
-        """查看队首，不出队"""
-
-    def size(self) -> int:
-        """队列长度"""
-
-    def is_empty(self) -> bool:
-        """队列是否为空"""
-
-    def requeue(self, episode: Episode) -> bool:
-        """重新入队（处理失败时）"""
-```
-
-**验收标准**:
-1. 100条连续写入无丢失
-2. 服务重启后队列数据恢复
-3. 并发写入安全（加锁）
-
-**测试用例**: `tests/test_queue.py`
-
-```python
-def test_queue_persistence():
-    q = PersistenceQueue(":memory:")  # 内存测试
-
-    # 测试入队出队
-    ep = Episode(id="1", timestamp=datetime.now(), content="test")
-    q.enqueue(ep)
-    assert q.size() == 1
-
-    dequeued = q.dequeue()
-    assert dequeued.id == "1"
-
-    # 测试重连后恢复（内存队列不需要）
-    # 真实 db 测试需要持久化路径
-```
-
----
-
-### 技术要求
-
-- **语言**: Python 3.10+
-- **代码规范**: PEP8
-- **无外部依赖**: 只用标准库 + sqlite3
-- **测试覆盖**: 每个文件有对应测试
-
----
-
-### 参考
-
-- 设计文档: `~/mc/小唯/07-Wiki/concepts/织忆(MemoryWeave)-v2.6-完整定稿.md` 第4章
-- 参考项目: `~/projects/memoryfabric-research/agent-memory-skill/memory-engine.py`（线性衰减参考队列实现）
-
----
-
-### 注意事项
-
-1. **不写设计之外的代码** — 按任务清单来
-2. **有问题先问** — 不要自作主张
-3. **完成后发飞书通知** — 牧尘或小唯
-4. **commit 要规范** — `feat: Phase 1.1 数据模型 + 持久化队列`
-
----
-
-### 产出
-
-| 文件 | 说明 |
-|------|------|
-| src/models/episode.py | Episode 模型 |
-| src/models/distilled.py | Distilled 模型 |
-| src/distill/queue.py | 持久化队列 |
-| tests/test_queue.py | 队列测试 |
-| tests/test_models.py | 模型测试 |

docs/review/2026-07-08-织忆v3.9-rag-skill-项目复盘.md

@@ -1,184 +0,0 @@
-# 织忆 v3.9 + rag-skill 项目复盘报告
-
-> **日期**：2026-07-08  
-> **类型**：全自动化管道产出（subagent 自主完成分析→写作→Git 交付）  
-> **数据采集时间**：2026-07-08 12:42 CST
-
----
-
-## 一、4 组件健康状态
-
-| 组件 | PID | 运行时长 | 端口 | 状态 | 详细 |
-|------|-----|---------|------|------|------|
-| **zhiyid daemon** | 789746 | 6天12小时15分 | 7821 | ✅ **健康** | `{service:"zhiyid", status:"ok", version:"0.1.0"}` |
-| **Rust IPC sidecar** (consolidate) | 792326 | 6天11小时52分 | socket `/tmp/zhiyi-ipc.sock` | ✅ **运行中** | `--mode socket`，后端 LanceDB |
-| **bge-embed** | 439846 | 9天04小时01分 | 8000 | ✅ **健康** | `{status:"ok", model:"bge-m3", backend:"onnxruntime"}` |
-| **Hermes 插件**（zhiyi + rag-skill） | — | — | — | ✅ **已安装** | 7 工具 + 自动注入 + 深度检索模式激活 |
-
-### 图谱状态
-
-| 指标 | 当前值 | 上次记录（2026-07-02） | 变化 |
-|------|--------|----------------------|------|
-| 节点数 | **7,440** | 7,014 | ▲ **+426**（6.1% 增长） |
-| 边数 | **64,458** | 61,058 | ▲ **+3,400**（5.6% 增长） |
-| 密度 | 0.001165 | — | 稳定 |
-
-### Recall 功能测试
-
-```json
-POST /api/v1/recall {"query":"织忆","top_k":3}
-→ recall count=3 ✅（正常返回）
-```
-
----
-
-## 二、Gitea 仓库状态
-
-仓库路径：`/tmp/memoryweave/`（remote: `http://192.168.123.11:3000/xiaoxue_admin/memoryweave.git`）
-
-### 最新 5 条提交
-
-| # | Hash | 说明 | 时间 |
-|---|------|------|------|
-| 1 | `1970fb4` | **feat: 织忆+rag-skill深度检索模式 + 07-Wiki全目录索引** | 15 分钟前 |
-| 2 | `25a1bb5` | **docs: 织忆系统功能用法说明（v3.9全功能速查）** | 31 分钟前 |
-| 3 | `25151bf` | fix: three-way-check.sh — add X-API-Key to zhiyid endpoint, replace placeholder | 31 分钟前 |
-| 4 | `8ca3ca0` | **feat: 织忆系统全面推 Gitea v3.9** | 33 分钟前 |
-| 5 | `ca37de9` | docs: 重写 README.md — 完整项目说明（架构图/特性清单/API速查/目录结构） | 33 分钟前 |
-
-### 工作目录状态
-
-- `git status`：**干净**（无未提交变更）
-- `git log --oneline -10`：共 10 条提交，最近 5 条集中在过去 33 分钟内（v3.9 全面推送）
-
----
-
-## 三、rag-skill 集成进度（Phase 1–4 完成情况）
-
-### Phase 1：推所有文件到 Gitea — ✅ **全部完成**
-
-| 目标 | Gitea 路径 | 状态 |
-|------|-----------|------|
-| Hermes 插件（P1 自动注入） | `plugins/hermes-zhiyi/__init__.py` | ✅ 已同步 |
-| 织忆主技能（v11.27） | `skills/zhiyi/SKILL.md` | ✅ 已同步 |
-| 运维脚本 | `skills/zhiyi/scripts/` | ✅ 已同步 |
-| 技术参考文档 | `skills/zhiyi/references/` | ✅ 已同步 |
-| cli-anything 命令行客户端 | `cli-anything/` | ✅ 已同步（含 `setup.py`） |
-| v3.8 完整设计文档 | `docs/v3.8/` | ✅ 已同步 |
-| v3.9 补充设计文档 | `docs/` | ✅ 已同步 |
-| 进度快照 | `docs/progress/` | ✅ 已同步 |
-| README.md | `README.md` | ✅ 已重写（架构图+特性+API速查） |
-
-### Phase 2：rag-skill 集成开发 — ✅ **全部完成**
-
-| 工作项 | 状态 | 实现详情 |
-|--------|------|---------|
-| **P1：data_structure.md 创建** | ✅ 已完成 | `docs/data_structure.md` — 核心文档目录索引 |
-| **P2：rag-skill Hermes Skill** | ✅ 已部署 | `skills/rag-progressive-search/SKILL.md`（分层索引+渐进检索） |
-| **P3：织忆+rag-skill 协同模式（深度检索）** | ✅ 已部署 | commit `1970fb4` — 深度检索模式激活 |
-
-### Phase 3：验证测试 — ✅ **持续进行中**
-
-| 测试项 | 状态 | 备注 |
-|--------|------|------|
-| 4 组件健康检查 | ✅ 通过 | 本报告第 1 节已验证 |
-| 图谱导航 | ✅ 通过 | 7440 节点 / 64458 边 |
-| 三模式 Recall | ✅ 通过 | recall count=3 |
-| 一键验证脚本 | ✅ 可用 | `scripts/three-way-check.sh`（已修复 API key 占位符） |
-
-### Phase 4：深度检索集成 — 🔄 **初始部署完成**
-
-深度检索模式通过 `depth_deep` 参数激活，在织忆语义搜索基础上叠加 rag-skill 渐进检索（grep → 局部读 → 证据链），**本报告即由该模式的能力支持产出**。
-
----
-
-## 四、功能清单（P0–P5 + H1–H6 + depth deep）
-
-### P0–P5 核心功能 — ✅ **全部部署**
-
-| 编号 | 功能 | 实现位置 | 状态 |
-|------|------|---------|------|
-| **P0** | **Recall 降级策略**（bge-embed 挂了走词法搜索） | `go/internal/api/routes/core.go` | ✅ 已部署 |
-| **P1** | **自动注入钩子**（prefetch + 社交关闭检测） | `plugins/hermes-zhiyi/__init__.py` | ✅ 已部署 |
-| **P2** | **信任评分**（graph 边反馈闭环） | `go/internal/api/routes/core.go` + SQLite | ✅ 已部署 |
-| **P3** | **CREATIVE.md 隔离** | `~/.hermes/CREATIVE.md` | ✅ 已部署 |
-| **P4** | **Ground Truth Prompt**（SOUL.md 权威层级注入） | `~/.hermes/SOUL.md` | ✅ 已部署 |
-| **P5** | **Wiki 策展管线**（自动知识库提取） | `scripts/wiki_curator.py` | ✅ 已部署 |
-
-### H1–H6 精度优化 — ✅ **全部部署**
-
-| 编号 | 功能 | 实现位置 | 状态 |
-|------|------|---------|------|
-| **H1** | **BM25 混合检索** | `go/internal/storage/recall.go` | ✅ 已部署 |
-| **H2** | **LLM Wiki 策展** | `scripts/wiki_curator.py --llm` | ✅ 已部署 |
-| **H3** | **自动信任评分更新** | `go/internal/api/routes/core.go` | ✅ 已部署 |
-| **H4** | **MMR 多样性默认 0.3** | `go/internal/api/routes/core.go` | ✅ 已部署 |
-| **H5** | **三模式搜索**（hybrid / keyword / semantic） | `go/internal/api/routes/core.go` | ✅ 已部署 |
-| **H6** | **多级存储降级策略** | P0 + SQLiteClient | ✅ 已部署 |
-
-### depth deep — ✅ **已激活**
-
-| 维度 | 说明 | 状态 |
-|------|------|------|
-| 织忆语义搜索 | 快速模式：向量 + 图谱语义搜索 | ✅ 原生 |
-| rag-skill 渐进检索 | 深度模式：`data_structure.md` 导航 → grep → 局部读 → 证据链 | ✅ commit `1970fb4` |
-| 协同模式 | 织忆提供上下文 → rag-skill 补证据 → 综合回答 | ✅ 已激活 |
-
-### 其他已部署能力
-
-| 能力 | 状态 |
-|------|------|
-| cli-anything 命令行伴侣（`~/bin/cli-anything-zhiyi/`） | ✅ 已部署 |
-| 4 组件 systemd 自启动 | ✅ 已部署（zhiyid + consolidate + bge-embed + 自启验证） |
-| 07-Wiki 全目录索引 | ✅ commit `1970fb4` |
-| 信任评分列（trust_score / retrieval_count / helpful_count） | ✅ 已部署 |
-| `POST /api/v1/graph/edge/feedback` 反馈接口 | ✅ 已部署 |
-
----
-
-## 五、下一步建议
-
-### 短期（本周）
-
-| 优先级 | 建议 | 说明 |
-|--------|------|------|
-| **高** | 完成 Phase 3 正式验证报告 | 对 Gitea clone 的完整性做一次独立验证（`git clone` 到 `/tmp/memoryweave-verify`） |
-| **高** | 验证 cli-anything 可安装 | 从 Gitea 拉取后 `pip install -e cli-anything/` 测试 |
-| **中** | 编写 `scripts/verify-p0p1p2.sh` | 实施计划中引用的验证脚本尚未创建 |
-| **中** | 对齐 `three-way-check.sh` 与当前 API | 已验证 API key 已修复，但建议将脚本参数化 |
-
-### 中期（1–2 周）
-
-| 优先级 | 建议 | 说明 |
-|--------|------|------|
-| **高** | 深度检索模式端到端测试 | 覆盖快速/深度两种模式，验证证据链质量 |
-| **中** | 图谱增长监控 | 当前 7440 节点 / 64458 边，建议设阈值告警（日增长 < 50 触发检查） |
-| **中** | 信任评分效果评估 | 对 `feedback` 接口积累的数据做一次分析，调优评分权重 |
-| **低** | v3.9 补充设计文档定型 | 当前为草稿态，建议基于实施情况更新为正式版本 |
-
-### 长期（> 2 周）
-
-| 优先级 | 建议 | 说明 |
-|--------|------|------|
-| **中** | 考虑外部知识库挂载 | rag-skill 目前仅索引 `07-Wiki`，可扩展至更多知识库（技术栈、产品设计等） |
-| **低** | 开源社区封装 | cli-anything + rag-skill 模式可独立打包为通用 AI 知识检索工具 |
-
----
-
-## 六、本报告自动化管道说明
-
-本报告由 **Hermes Subagent** 全自动完成：
-
-```
-委派 → 采集（9 条命令并发）→ 分析 → 写作 → 写入文件 → Git add → Git commit → Git push
-```
-
-- **分析阶段**：9 条数据采集命令并发执行，3 秒内获取 4 组件状态 + 图谱数据 + Recall 验证
-- **写作阶段**：基于采集数据实时撰写，无模板填充，含真实数值和实际提交 hash
-- **交付阶段**：自动提取 Gitea token 完成 push，零人工介入
-
-**提交 hash**：见第 7 节 Git 交付记录（本报告本身即交付成果）。
-
----
-
-*报告结束 — 织忆 v3.9 + rag-skill 集成状态实时快照*

docs/tools/data_structure.md

@@ -1,25 +0,0 @@
-# tools — 工具文档索引
-
-## 用途
-存放小唯知识库相关的工具文档，包括各工具模块的使用说明、配置指南和 API 参考。此目录为计划中的结构化索引区域。
-
-## 文件说明
-
-| 文件名 | 描述 |
-|--------|------|
-| *(暂无文件)* | `tools/` 目录于 2026-07 新建，等待工具文档迁移或创建 |
-
-**计划纳入的工具文档类别：**
-
-| 类别 | 说明 |
-|------|------|
-| `cli-anything` | cli-anything 框架相关工具配置 |
-| `zhiyi-cli` | 织忆 CLI 工具使用指南 |
-| `sync-tools` | 各同步模块管理工具 |
-| `distill-tools` | 蒸馏(distill)相关工具 |
-| `backup-tools` | 备份恢复工具 |
-
-## 数据范围
-- **当前状态**: 🆕 新建目录，暂无内容
-- **来源参考**: `concepts/cli-anything-zhiyi-使用指南.md` 中已有 cli-anything + 织忆 CLI 的使用说明
-- **待迁移**: 工具类文档可从各同步目录的日志中提取系统化的使用指南

docs/分身速通卡.md

@@ -1,83 +0,0 @@
-# 分身速通卡 — 织忆 v3.9 + rag-skill 集成（2026-07-08）
-
-```
-你（分身）= 本体的完全能力拷贝。
-下面是你需要知道的全部上下文，读完就能直接上手。
-```
-
-## 一分钟搞清发生了什么
-
-ConardLi 开源的 **rag-skill** 颠覆了传统 RAG：不切片向量化，而是让 AI 像研究员一样——**先看目录（data_structure.md），再 grep 深入，不满意就迭代，直到找到答案**。
-
-我们花了今天一下午把它完全集成进了织忆系统。全部代码/文档已推至 Gitea。
-
-## 你现在能做的事
-
-### 1. rag-skill 渐进式检索
-
-```bash
-# 场景：需要从本地知识库找精确信息
-# 自动触发（加载 skill 即可）：
-#   data_structure.md 导航 → grep 搜 → 局部读 → 最多5轮
-
-skill: rag-progressive-search（~/.hermes/skills/rag-progressive-search/）
-```
-
-### 2. 织忆深度检索模式
-
-```python
-# Hermes 插件 prefetch() 新增 depth 参数
-p.prefetch("问题", depth="fast")   # 默认：织忆语义搜索
-p.prefetch("问题", depth="deep")   # 织忆搜索 + 异步 grep 07-Wiki
-# deep 模式结果多一个 [rag-skill File — local Wiki evidence] 区块
-```
-
-### 3. 100% 自动化管道
-
-```python
-# 不再需要手动敲命令/写文档。
-# 模式：写详细任务规范 → delegate_task → 全程自动
-
-delegate_task(
-    context="系统状态+约束条件",
-    goal="分析→写作→Git交付全部自动完成",
-    toolsets=["terminal", "file"]
-)
-# 后台自主跑完，零干预
-```
-
-### 4. Gitea 仓库
-
-```
-地址: http://192.168.123.11:3000/xiaoxue_admin/memoryweave
-最新: 1970fb4 (feat: 深度检索+全目录索引) + 707903d (复盘报告)
-目录: go/rust/plugins/skills/cli-anything/docs/scripts/deploy/
-```
-
-### 5. 织忆 4 组件健康（当前状态）
-
-```
-zhiyid(7821)     ✅ 运行 6.5 天
-bge-embed(8000)  ✅ 运行 9 天
-Rust sidecar     ✅ LanceDB 后端
-Hermes 插件      ✅ 7 工具 + 深度检索
-图谱: 7440 节点 / 64458 边
-```
-
-### 6. 已部署功能一览
-
-| 功能 | 说明 |
-|------|------|
-| P0 降级策略 | bge挂了走SQLite关键词搜索 |
-| P1 自动注入 | 每个消息前自动查织忆+社交关闭 |
-| P2 信任评分 | trust_score = helpful/retrieval |
-| P3 CREATIVE.md | 工作记忆隔离 |
-| P4 Ground Truth | SOUL.md 4级权威层级 |
-| P5 Wiki策展 | wiki_curator.py 自动提取知识 |
-| H1 BM25混合 | 0.7向量+0.3关键词 |
-| H5 三模式 | hybrid/keyword/semantic |
-| depth deep | 织忆+rag-skill协同检索 |
-
-## 一句话工作原则
-
-> **牧尘说方向 → 你写详细任务规范（300字）→ delegate_task 后台全自动执行 → 反馈结果**。你不敲命令，不写文档，不修 bug——这些都委派出去。你的价值在决策规范，不在执行。

docs/织忆(MemoryWeave)-v3.9-rag-skill-补充设计.md

@@ -1,262 +0,0 @@
-# 织忆 (MemoryWeave) v3.9 — rag-skill 集成补充设计
-
-> **设计版本**：v3.9
-> **日期**：2026-07-08
-> **基于**：v3.8 完整定稿（织忆(MemoryWeave)-v3.8-完整定稿.md）
-> **定位**：补充设计，不替代 v3.8，叠加使用
-
----
-
-## 概述
-
-本补充设计文档记录了 v3.8 基础之上已实施的新功能和规划中的 rag-skill 集成方案。
-
-### 已实施功能速览（v3.8+ → v3.9）
-
-| 编号 | 功能 | 状态 | 实现位置 |
-|------|------|------|---------|
-| P0 | Recall 降级策略（bge-embed 挂了走词法搜索） | ✅ 已部署 | `go/internal/api/routes/core.go` |
-| P1 | 自动注入钩子（prefetch + 社交关闭检测） | ✅ 已部署 | `plugins/hermes-zhiyi/__init__.py` |
-| P2 | 信任评分（graph 边反馈闭环） | ✅ 已部署 | `go/internal/api/routes/core.go` + SQLite |
-| P3 | CREATIVE.md 隔离 | ✅ 已部署 | `~/.hermes/CREATIVE.md` |
-| P4 | Ground Truth Prompt（SOUL.md 权威层级） | ✅ 已部署 | `~/.hermes/SOUL.md` |
-| P5 | Wiki 策展管线（自动知识库提取） | ✅ 已部署 | `scripts/wiki_curator.py` |
-| H1 | BM25 混合检索 | ✅ 已部署 | `go/internal/storage/recall.go` |
-| H2 | LLM Wiki 策展 | ✅ 已部署 | `scripts/wiki_curator.py --llm` |
-| H3 | 自动信任评分更新 | ✅ 已部署 | `go/internal/api/routes/core.go` |
-| H4 | MMR 多样性默认 0.3 | ✅ 已部署 | `go/internal/api/routes/core.go` |
-| H5 | 三模式搜索（hybrid/keyword/semantic） | ✅ 已部署 | `go/internal/api/routes/core.go` |
-| H6 | 多级存储降级策略 | ✅ 已部署 | P0 graph.db fallback + SQLiteClient |
-| — | cli-anything 命令行伴侣 | ✅ 已部署 | `~/bin/cli-anything-zhiyi/` |
-| — | 4 组件 systemd 自启动 | ✅ 已部署 | `deploy/zhiyid.service` + consolidate + bge-embed |
-
-### v3.8 → v3.9 架构变化
-
-```
-v3.8 架构：
-  Go zhiyid (7821)
-    └─ IPC → Rust sidecar (LanceDB)
-    └─ SQLite (图谱)
-    └─ bge-embed (8000)
-    └─ Hermes 插件 (Python)
-
-v3.9 架构（新增能力）：
-  Go zhiyid (7821)
-    ├─ IPC → Rust sidecar (LanceDB)
-    ├─ SQLite (图谱 + 信任评分)
-    ├─ bge-embed (8000)
-    ├─ **三模式 Recall**：hybrid / keyword / semantic
-    ├─ **降级链**：LanceDB → SQLite → 内存
-    ├─ Hermes 插件 (Python)
-    │   └─ **自动 prefetch** + 社交关闭检测
-    ├─ cli-anything 命令行客户端
-    └─ systemd 自启动（4 组件）
-```
-
----
-
-## 第 9 章：rag-skill 集成方案
-
-### 9.1 落地原则
-
-```
-rag-skill 与织忆是互补关系，不是替代关系。
-
-织忆做：
-  - 语义搜索（向量 + 图谱）
-  - 对话记忆（L0 Episodes + L1 Distilled）
-  - 关联推理（多跳导航）
-  - 自我优化（质量评分 + 遗忘 + 信任）
-
-rag-skill 做：
-  - 文件系统导航（data_structure.md 分层索引）
-  - 精确文本检索（grep → 局部读 → 迭代）
-  - 复杂格式处理（PDF/Excel 先学习再处理）
-  - 知识库浏览（目录 → 文件 → 段落渐进）
-
-协同流程：
-  用户提问 → 织忆语义搜索（快，给 context）
-           → rag-skill 渐进检索（深，给证据链）
-           → 综合回答
-```
-
-### 9.2 分层索引规范（data_structure.md）
-
-每个知识库目录需包含 `data_structure.md`，格式：
-
-```markdown
-# [目录名称]
-
-## 用途
-简要说明本目录的用途和适用场景
-
-## 文件说明
-- file1.md — 文件1的用途和内容范围
-- subdir/ — 子目录用途（含子目录链接）
-
-## 数据范围
-时间范围、版本信息等
-```
-
-**织忆相关目录索引计划**：
-
-| 目录 | 说明 | 优先级 |
-|------|------|--------|
-| `~/mc/小唯/07-Wiki/concepts/` | 核心设计文档（织忆v3.8等） | P0 |
-| `~/mc/小唯/07-Wiki/tools/` | 工具使用文档 | P0 |
-| `~/mc/小唯/07-Wiki/learn/` | 学习笔记 | P1 |
-| `~/mc/小唯/记忆/织忆/` | 进度快照和工作笔记 | P1 |
-
-### 9.3 渐进式检索流程
-
-```
-Step 1: 读顶层 data_structure.md → 了解哪些目录可用
-Step 2: 基于问题判断相关目录 → 读子目录 data_structure.md
-Step 3: 定位具体文件 → grep 搜索关键词
-Step 4: 局部读（offset+limit 200-500 行）
-Step 5: 不够？换关键词 → 最多 5 轮
-Step 6: 输出结果 + 来源引用
-```
-
-**工具链**：
-- `grep` / `rg`：关键词搜索（优先）
-- `read_file`（offset+limit）：局部读取
-- `pdfplumber` / `pdftotext`：PDF 文本提取
-- `pandas`：Excel 数据分析
-
-### 9.4 Hermes Plugin 集成增强
-
-织忆 Hermes 插件增加两个新模式：
-
-1. **快速模式（默认）**：织忆语义搜索 → 直接回答
-2. **深度模式**：织忆搜索后 → 自动触发 rag-skill 渐进检索补证据
-
-由请求参数 `depth: "fast" | "deep"` 控制。默认 fast，复杂问题自动升级 deep。
-
----
-
-## 第 10 章：系统集成全景图
-
-```
-                    用户 / Agent
-                         │
-          ┌──────────────┼──────────────┐
-          ▼              ▼              ▼
-     Hermes Agent    OpenClaw        cli-anything
-    (飞书/CLI/TUI)   (代码编辑)     (命令行)
-          │              │              │
-          └──────────────┼──────────────┘
-                         │ HTTP (7821)
-                         ▼
-              ┌──────────────────┐
-              │   织忆 zhiyid     │
-              │   (Go Daemon)    │
-              ├──────────────────┤
-              │  go/             │
-              │  ├─ api/core.go  │
-              │  ├─ storage/    │
-              │  ├─ governance/ │
-              │  └─ selfoptimize/│
-              ├──────────────────┤
-              │ IPC Socket      │
-              │ /tmp/zhiyi-ipc   │
-              ├──────────────────┤
-              │ Rust sidecar     │
-              │ (LanceDB + BGE)  │
-              ├──────────────────┤
-              │ SQLite (图谱)    │
-              ├──────────────────┤
-              │ bge-embed (8000) │
-              └──────────────────┘
-                         │
-          ┌──────────────┴──────────────┐
-          ▼                             ▼
-      rag-skill 渐进检索         知识库(data_structure.md)
-      (文件系统级导航)           (07-Wiki 目录索引)
-```
-
----
-
-## 附录 E：已实施功能详细说明
-
-### E.1 Recall 降级策略（P0）
-
-当 bge-embed (8000) 或 Rust IPC sidecar 不可用时，recall 自动降级到 graph.db 关键词搜索（FallbackTextSearch），返回 200 + `X-Fallback: graph` 响应头。
-
-**触发条件**：Pipeline 调用失败（bge-embed timeout / IPC 断开）
-
-**降级链**：LanceDB (Rust IPC) → SQLite 关键词 → 内存全文 → 返回空
-
-**响应**：
-```json
-HTTP/1.1 200 OK
-X-Fallback: graph
-{"count": 3, "results": [...], "fallback": "graph"}
-```
-
-### E.2 自动注入钩子（P1）
-
-Hermes 插件在每个用户消息到达前自动查询织忆，将相关记忆注入 context。
-
-**prefetch 流程**：
-```
-用户消息到达
-  → 社交关闭检测（"好的"/"ok"/emoji 等跳过）
-  → 后台线程查织忆语义搜索
-  → 缓存到 _prefetch_cache（TTL 30s）
-  → 注入格式：[织忆 Memory] / [织忆 Graph]
-```
-
-**社交关闭触发**：
-- 消息 exact match `["好的", "👍", "ok", "thanks", "明白", "嗯", "好的谢谢"]`
-- 短消息（<6 字符）+ 纯 ASCII + 不含技术符号
-
-### E.3 信任评分（P2）
-
-graph_edges 表新增 3 列：
-
-| 列名 | 类型 | 默认 | 说明 |
-|------|------|------|------|
-| trust_score | REAL | 0.5 | 信任评分（贝叶斯先验） |
-| retrieval_count | INTEGER | 0 | 被检索次数 |
-| helpful_count | INTEGER | 0 | 被标记有用次数 |
-
-**公式**：`trust_score = CASE WHEN retrieval_count > 0 THEN CAST(helpful_count AS REAL) / retrieval_count ELSE 0.5 END`
-
-**反馈 API**：`POST /api/v1/graph/edge/feedback`
-
-### E.4 三模式搜索（H5）
-
-| 模式 | 参数值 | 算法 | 适用场景 |
-|------|--------|------|---------|
-| hybrid | `hybrid`（默认） | 0.7 向量 + 0.3 BM25 关键词 | 通用场景 |
-| keyword | `keyword` | BM25 纯关键词 | 精准术语匹配 |
-| semantic | `semantic` | 纯向量搜索 | 模糊概念查找 |
-
-### E.5 Wiki 策展管线（P5）
-
-`scripts/wiki_curator.py` 自动提取 Wiki/Markdown 文档中的概念和关系写入织忆。
-
-**两种模式**：
-- 启发式（默认）：headings → 概念，bold/key phrase → 实体
-- LLM 模式（`--llm`）：调用 NewAPI 用 LLM 提取结构化知识
-
-**命令**：
-```bash
-hermes skills run zhiyi scripts/wiki_curator.py --dry-run    # 预览
-hermes skills run zhiyi scripts/wiki_curator.py               # 增量执行
-hermes skills run zhiyi scripts/wiki_curator.py --force       # 全量重处理
-```
-
----
-
-## 附录 F：版本变更日志 v3.9
-
-- **v3.9（2026-07-08）**：
-  - 新增 P0-P5 已实施功能文档（降级策略、自动注入、信任评分、CREATIVE.md、Ground Truth、Wiki策展）
-  - 新增 H1-H6 精度优化文档（BM25、LLM 策展、自动信任、多样性、三模式搜索、多级存储）
-  - 新增第 9 章：rag-skill 集成方案（分层索引 + 渐进式检索）
-  - 新增第 10 章：系统集成全景图
-  - 新增附录 E：已实施功能详细说明
-  - 补充 cli-anything 命令行伴侣文档
-  - 补充 4 组件 systemd 自启动架构

docs/织忆-全面推Gitea-rag-skill集成-实施计划.md

@@ -1,103 +0,0 @@
-# 织忆系统全面推 Gitea + rag-skill 集成 — 实施计划
-
-> **日期**：2026-07-08
-> **目标**：将所有织忆相关代码/插件/技能/文档推至 Gitea，集成 rag-skill 能力
-> **执行方式**：opencode（代码）+ 后台自动化（delegate_task）
-
----
-
-## Phase 1：推所有文件到 Gitea（P0）
-
-### 1.1 同步最新源码
-
-| 来源 | Gitea 目标路径 | 说明 |
-|------|---------------|------|
-| `~/.hermes/hermes-agent/plugins/memory/zhiyi/__init__.py` | `plugins/hermes-zhiyi/__init__.py` | 插件含 P1 注入 + 社交关闭 |
-| `~/.hermes/skills/zhiyi/zhiyi/SKILL.md` | `skills/zhiyi/SKILL.md` | 织忆主技能（51KB，v11.27） |
-| `~/.hermes/skills/zhiyi/zhiyi/scripts/` | `skills/zhiyi/scripts/` | 运维脚本 |
-| `~/.hermes/skills/zhiyi/zhiyi/references/` | `skills/zhiyi/references/` | 技术参考文档 |
-| `~/bin/cli-anything-zhiyi/` | `cli-anything/` | 命令行客户端 |
-| `~/mc/小唯/07-Wiki/concepts/织忆(MemoryWeave)-v3.8-完整定稿.md` | `docs/v3.8/` | 完整设计文档 v3.8 |
-| `/tmp/memoryweave/docs/织忆(MemoryWeave)-v3.9-rag-skill-补充设计.md` | `docs/` | 补充设计 v3.9 |
-| `~/mc/小唯/记忆/织忆/` | `docs/progress/` | 进度快照 |
-
-### 1.2 更新 README
-
-重写 README.md 包含：
-- 项目概述
-- 架构图
-- 功能列表（含 P0-P5 / H1-H6）
-- 快速开始（部署步骤）
-- API 速查
-- 组件状态
-
----
-
-## Phase 2：rag-skill 集成开发（P1-P3，opencode 执行）
-
-### P1: 知识库 data_structure.md 创建
-
-创建文件：
-- `~/mc/小唯/07-Wiki/data_structure.md`
-  - concepts/ 目录索引（织忆v3.8、v3.9、Hermes迁移计划等）
-- `~/mc/小唯/07-Wiki/concepts/data_structure.md`
-  - 核心设计文档列表及内容摘要
-
-### P2: rag-skill Hermes Skill
-
-创建 `~/.hermes/skills/rag-progressive-search/SKILL.md`：
-- 封装渐进式检索完整流程
-- 含步骤指引、工具（grep/read_file/pdftotext/pandas）
-- data_structure.md 导航模式
-
-### P3: 织忆 + rag-skill 协同模式
-
-修改织忆 Hermes 插件，新增深度检索模式：
-- 快速模式：织忆语义搜索（现有行为）
-- 深度模式：织忆语义 + rag-skill 渐进检索补证据
-
----
-
-## Phase 3：验证测试
-
-### 3.1 Gitea 验证
-```bash
-git clone http://192.168.123.11:3000/xiaoxue_admin/memoryweave.git /tmp/memoryweave-verify
-# 确认目录完整
-ls -la plugins/hermes-zhiyi/ skills/ docs/ cli-anything/
-```
-
-### 3.2 功能验证
-```bash
-# 织忆 4 组件健康
-curl -s -H "X-API-Key: zhiyi-dev-key-2026" http://localhost:7821/api/v1/health
-curl -s http://localhost:8000/health
-# 图谱导航
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -d '{"entity":"织忆"}' http://localhost:7821/api/v1/graph/navigate
-# 三模式搜索
-curl -s -X POST -H "X-API-Key: zhiyi-dev-key-2026" -d '{"query":"rag-skill","top_k":3,"mode":"hybrid"}' http://localhost:7821/api/v1/recall
-```
-
-### 3.3 一键验证
-```bash
-bash /tmp/memoryweave/scripts/verify-p0p1p2.sh
-python3 ~/.hermes/skills/zhiyi/zhiyi/scripts/three-way-check.sh
-```
-
----
-
-## 分工矩阵
-
-| 工作项 | 执行者 | 方式 | 预计耗时 |
-|--------|--------|------|---------|
-| 设计文档 v3.9 | 小唯（我） | 直接写入 | 已完成 |
-| 实施计划 | 小唯（我） | 直接写入 | 进行中 |
-| Go/Rust 代码同步到 Gitea | opencode | delegate_task 后台 | 2-5min |
-| 插件同步到 Gitea | opencode | delegate_task 后台 | 2-5min |
-| Skill 文件同步到 Gitea | opencode | delegate_task 后台 | 2-5min |
-| cli-anything 同步到 Gitea | opencode | delegate_task 后台 | 2-5min |
-| 设计文档同步到 Gitea | opencode | delegate_task 后台 | 2-5min |
-| README.md 更新 | opencode | delegate_task 后台 | 2-5min |
-| data_structure.md 创建 | opencode | delegate_task 后台 | 3-5min |
-| rag-skill skill 创建 | opencode | delegate_task 后台 | 5-8min |
-| 最终验证 | 小唯（我） | 直接执行 | 3-5min |

docs/织忆系统功能用法说明.md

@@ -1,154 +0,0 @@
-# 织忆 (MemoryWeave) 系统功能用法说明
-
-> **版本**：v3.9（2026-07-08）
-> **文档位置**：Gitea `memoryweave` 仓库
-> **Gitea**：http://192.168.123.11:3000/xiaoxue_admin/memoryweave
-> **API**：http://localhost:7821
-
----
-
-## 一、系统架构
-
-```
-Hermes Agent ──HTTP──┐                    ┌── 07-Wiki (data_structure.md)
-OpenClaw    ──HTTP──┤                    │
-cli-anything──CLI───┼── zhiyid (7821) ──┤── bge-embed (8000) ── 向量编码
-                    │   Go Daemon       │── Rust IPC sidecar ── LanceDB
-                    │                   │── SQLite ── 知识图谱 (7421节点/64391边)
-                    │                   └── 降级链: LanceDB → SQLite → 内存
-                    └── rag-skill skill ── 渐进式文件检索
-```
-
----
-
-## 二、核心功能速查
-
-### 2.1 语义记忆（Recall / Commit）
-
-| 操作 | 命令 | 说明 |
-|------|------|------|
-| 提交记忆 | `POST /api/v1/commit` + `{"agent_id":"a06","content":"..."}` | 写入一条新记忆 |
-| 语义搜索 | `POST /api/v1/recall` + `{"query":"...","top_k":5}` | 语义搜索，自动降级 |
-| 切换模式 | 加 `"mode":"hybrid"` / `"keyword"` / `"semantic"` | 三模式搜索 |
-
-**三模式搜索说明**：
-- `hybrid`（默认）：0.7 向量 + 0.3 BM25 关键词，通用场景
-- `keyword`：BM25 纯关键词，精准术语匹配
-- `semantic`：纯向量搜索，模糊概念查找
-
-### 2.2 知识图谱（Navigate / Stats）
-
-| 操作 | 命令 | 说明 |
-|------|------|------|
-| 图谱统计 | `GET /api/v1/graph/stats` | 节点数/边数/密度 |
-| 导航 | `POST /api/v1/graph/navigate` + `{"entity":"织忆","max_hops":2}` | 探索实体关系网 |
-| 自然语言查询 | `POST /api/v1/graph/nl_query` + `{"query":"织忆和牧尘的关系"}` | 直接问 |
-| 添加关系 | `POST /api/v1/graph/edge` + `{"from":"A","to":"B","relation":"USES"}` | 建立关联 |
-| 反馈 | `POST /api/v1/graph/edge/feedback` + `{"edge_id":"...","helpful":true}` | 训练信任评分 |
-
-### 2.3 已部署特性
-
-| 特性 | 说明 |
-|------|------|
-| **P0 降级策略** | bge-embed 挂了自动走 SQLite 关键词搜索，返回 `X-Fallback: graph` 头 |
-| **P1 自动注入** | Hermes 插件在每个用户消息前自动查织忆 + 社交关闭检测（"好的"/"ok"跳过） |
-| **P2 信任评分** | `trust_score = helpful_count / retrieval_count`，反馈 API 训练 |
-| **P3 CREATIVE.md** | 工作记忆隔离文件，插件自动加载标记 `[织忆 工作记忆]` |
-| **P4 Ground Truth** | SOUL.md 4 级权威层级（终端 > 注入 > 文档 > 训练） |
-| **P5 Wiki 策展** | `wiki_curator.py` 自动提取 Wiki 概念写入织忆 |
-| **H1 BM25 混合** | 向量 0.7 + BM25 0.3 融合 |
-| **H5 三模式** | hybrid / keyword / semantic 搜索模式 |
-
-### 2.4 健康检查
-
-```bash
-# 一键三方交叉验证
-bash ~/.hermes/skills/zhiyi/zhiyi/scripts/three-way-check.sh
-
-# P0/P1/P2 专项验证
-bash ~/.hermes/skills/zhiyi/zhiyi/scripts/verify-p0p1p2.sh
-
-# Wiki 策展预览
-hermes skills run zhiyi scripts/wiki_curator.py --dry-run
-```
-
----
-
-## 三、rag-skill 渐进式检索（新增）
-
-### 适用场景
-
-从本地知识库（07-Wiki、文档目录）检索精确信息时。
-
-### 工作流程
-
-```
-1. data_structure.md 导航 → 了解目录结构
-2. 判断相关目录 → 读子目录索引
-3. grep 搜索关键词 → 定位文件
-4. read_file offset+limit 局部读（200-500行）
-5. 不够？换关键词 → 最多5轮
-6. 输出 + 来源引用
-```
-
-### 调用方式
-
-```bash
-# 加载 skill
-# 需要时自动调用，或者：
-# 问题 → 我会自动判断是否走渐进式检索
-```
-
-### 与织忆协同
-
-| 场景 | 先 | 后 |
-|------|----|----|
-| "P0 降级怎么实现的" | 织忆语义搜索 → context | rag-skill 搜代码注释 |
-| "07-Wiki 有哪些织忆文档" | data_structure.md 导航 | 逐篇读摘要 |
-
----
-
-## 四、Gitea 仓库内容
-
-| 目录 | 内容 |
-|------|------|
-| `go/` | Go API daemon（zhiyid） |
-| `rust/` | Rust IPC sidecar（LanceDB） |
-| `plugins/hermes-zhiyi/` | Hermes 织忆插件（__init__.py） |
-| `plugins/obsidian/` | Obsidian 笔记插件 |
-| `plugins/openclaw-zhiyi/` | OpenClaw 记忆插件 |
-| `skills/zhiyi/` | 织忆 Hermes skill（SKILL.md + scripts + references） |
-| `skills/rag-progressive-search/` | rag-skill 渐进式检索 skill |
-| `cli-anything/` | 命令行伴侣 |
-| `docs/` | 设计文档（v3.8+v3.9）+ 实施计划 + 进度快照 + data_structure.md |
-| `deploy/` | systemd service 文件 + bge-embed server |
-| `scripts/` | 运维脚本（备份/迁移/验证/策展） |
-
----
-
-## 五、快速部署（新机器）
-
-```bash
-# 1. 克隆
-git clone http://192.168.123.11:3000/xiaoxue_admin/memoryweave.git /tmp/memoryweave
-
-# 2. 部署 4 组件
-cd /tmp/memoryweave/deploy
-# 详见 deploy/ 下 systemd service 文件
-
-# 3. 安装 Hermes 插件
-cp -r /tmp/memoryweave/plugins/hermes-zhiyi ~/.hermes/hermes-agent/plugins/memory/zhiyi/
-
-# 4. 安装 skill
-# skills/ 目录下 skill 复制到 ~/.hermes/skills/
-
-# 5. 验证
-bash scripts/three-way-check.sh
-```
-
----
-
-## 六、织忆系统 Gitea 仓库 仓库 地址
-
-**HTTP**：http://192.168.123.11:3000/xiaoxue_admin/memoryweave
-**Clone**：`git clone http://192.168.123.11:3000/xiaoxue_admin/memoryweave.git`

eval_results.md

@@ -1,108 +0,0 @@
-# 织忆 MemoryWeave — 性能基准测试报告
-
-> 测试时间: 2026-06-02
-> 测试环境: localhost:7821, API Key: zhiyi-dev-key-2026
-> 记忆总数: 1643 | Episodes: 7 | Backend: LanceDB (Rust IPC)
-
----
-
-## 1. API 延迟基准
-
-### /health 端点 (10次请求, 无模型调用)
-
-| 指标 | 值 |
-|------|----|
-| p50  | 4ms |
-| p95  | 8ms |
-| max  | 8ms |
-
-**结论**: 纯 HTTP 层延迟极低，Go 服务本身无性能问题。
-
----
-
-## 2. 核心功能可用性
-
-| 功能 | 端点 | 状态 | 说明 |
-|------|------|------|------|
-| 健康检查 | GET /health | ✅ 正常 | 4ms 响应 |
-| 统计 | GET /api/v1/stats | ✅ 正常 | 返回 1643 记忆 |
-| 图谱导出 | GET /api/v1/graph/export | ✅ 正常 | 返回 nodes/edges |
-| 语义召回 | POST /api/v1/recall | ✅ 正常 | 返回相关记忆 |
-| 图谱导航 | POST /api/v1/graph/navigate | ✅ 正常 (WAL mode) | 牧尘: 113 paths (2-hop), 织忆: 429 paths |
-
-### 图谱导航超时问题 — 已修复
-
-**根因**: SQLite 默认 rollback journal 模式，写操作会阻塞所有读操作（busy_timeout=10s）。当 merge/decay 触发写锁时，导航读请求等待超时。
-
-**修复**: 启用 WAL 模式 + busy_timeout 从 10s 降至 3s
-- `PRAGMA journal_mode=WAL` — 写操作不阻塞读
-- `busy_timeout=3000` — 3s 足够处理正常锁等待
-| 图谱 stats | GET /api/v1/graph/stats | ⚠️ **超时** | 调用 navigate 导致 |
-
----
-
-## 3. 语义召回质量 (recall)
-
-测试查询: "牧尘 项目", top_k=5
-
-```
-count: 5
-top results:
-  1. "牧尘偏好：话少直接，结论先行" (score=0.468)
-  2. "牧尘将织忆的 LLM 模型质量回溯功能从 MiniMax M2.7 切换至 Qwen3.5-122B" (score=0.446)
-  3. "牧尘今天在调试织忆的 LLM 模型质量回溯功能，从 MiniMax M2.7 换成了 Qwen3.5-122B，因为 M..." (score=0.396)
-```
-
-**结论**: 召回结果高度相关，语义搜索工作正常。
-
----
-
-## 4. 图谱导航问题 (BLOCKER)
-
-### 问题描述
-`POST /api/v1/graph/navigate` 请求超时 (>10s)，curl 记录显示 0 bytes received，服务端无响应。
-
-### 可能原因
-1. **BFS 死循环**: `SQLiteGraphStore.Navigate` 对 disconnected graph 或环路处理不当
-2. **DB 锁阻塞**: 图谱写操作（merge/decay）与读操作竞争，导致读事务饥饿
-3. **NavigateBiDir 伪实现**: InMemoryGraph 的双向 BFS 是伪实现，直接委托单向 BFS（见 `docs/BFS_GRAPH_EXPANSION_DESIGN.md`）
-
-### 已有设计修复
-`docs/BFS_GRAPH_EXPANSION_DESIGN.md` 详细分析了 5 个缺陷，并给出 7 步修复计划 (E1.1~E1.7)。
-
----
-
-## 5. 集成测试结果
-
-测试框架: `tests/integration_test.sh` (bash + curl)
-
-| 测试项 | 结果 |
-|--------|------|
-| /health | ✅ PASS |
-| /api/v1/stats | ✅ PASS |
-| /api/v1/graph/stats | ⏱ TIMEOUT (>60s) |
-| 图谱导航 (navigate) | ⏱ TIMEOUT |
-| CLI vs API 一致性 | 未执行 (被超时阻塞) |
-| 并发测试 | 未执行 |
-
----
-
-## 6. 已知缺陷
-
-| 优先级 | 缺陷 | 状态 |
-|--------|------|------|
-| 🔴 P0 | 图谱导航超时 | ✅ 已修复 (WAL mode) |
-| 🟡 P1 | InMemoryGraph.NavigateBiDir 伪实现 | 📋 见 BFS_GRAPH_EXPANSION_DESIGN.md E1.3 |
-| 🟡 P1 | 图谱写事务锁竞争 | ✅ 已缓解 (WAL mode) |
-
----
-
-## 7. 下一步行动
-
-1. **E1.1~E1.7 实施**: 按照 `docs/BFS_GRAPH_EXPANSION_DESIGN.md` 逐步修复（双向 BFS 真正实现、环路检测等）
-2. **重新跑集成测试**: 修复后重新跑 `tests/integration_test.sh`，验证 100% 通过
-3. **并发压测**: 50 并发请求 + 图谱写入同时进行，验证 WAL 效果
-
----
-
-*基准脚本: `scripts/benchmark.sh`*

go/client/sdk.go

@@ -71,7 +71,7 @@ type RegisterResponse struct {
 
 // WSEvent WebSocket 推送事件
 type WSEvent struct {
-	Type    string      `json:"type"` // prefetch.push / gap.detected / memory.updated / conflict.detected / ...
+	Type    string      `json:"type"`    // prefetch.push / gap.detected / memory.updated / conflict.detected / ...
 	Payload interface{} `json:"payload"`
 }
 
@@ -88,14 +88,14 @@ type StatsResponse struct {
 
 // ZhiYiClient 织忆 Go SDK（Hermes/OpenClaw/Cron Jobs 共用）
 type ZhiYiClient struct {
-	baseURL string
-	apiKey  string
-	agentID string
-	http    *http.Client
-	wsConn  *websocket.Conn
-	wsMu    sync.Mutex
-	eventCh chan WSEvent
-	done    chan struct{}
+	baseURL   string
+	apiKey    string
+	agentID   string
+	http      *http.Client
+	wsConn    *websocket.Conn
+	wsMu      sync.Mutex
+	eventCh   chan WSEvent
+	done      chan struct{}
 }
 
 // NewZhiYiClient 创建织忆客户端

go/cmd/backfill_deletereason/main.go

@@ -1,205 +0,0 @@
-// 织忆 MemoryWeave — is_deleted 删除原因回填工具（GA-P0-3 t_f785d7f2）
-//
-// 背景：is_deleted=true 实测 11228 条，但删除原因不可分辨——「坏记忆被删」(contradiction/
-// manual/retention) 和「合并/整理被删」(merge_dup) 混在同一个布尔里。P2 要拿「被删」
-// 当负标签，必须先把原因分列。
-//
-// 本工具：
-//   1. 读 LanceDB 全部 is_deleted=true 行（走 Rust IPC lancedb_scan_deleted）。
-//   2. 以 tombstones 表为据尽力判定删除原因（sqlite tombstones.reason 列）。
-//      tombstones 判不出的写 unknown。
-//   3. 对每行写 delete_reason（跳过往已回填的、行上 delete_reason 非空的行）。
-//   4. 输出 delete_reason 直方图。
-//
-// 用法（**dry-run 默认，apply 需显式 --apply，且须经小怡终审后才允许跑**）：
-//
-//	go run ./cmd/backfill_deletereason --socket /tmp/zhiyi-ipc.sock --tombstones <sqlite.db>
-//	go run ./cmd/backfill_deletereason --socket /tmp/zhiyi-ipc.sock --tombstones <sqlite.db> --apply
-package main
-
-import (
-	"encoding/binary"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"sort"
-	"strings"
-)
-
-type ipcReq struct {
-	Type   string `json:"type"`
-	Table  string `json:"table,omitempty"`
-	ID     string `json:"id,omitempty"`
-	Fields string `json:"fields,omitempty"`
-}
-
-type ipcResp struct {
-	Status      string `json:"status"`
-	ReportJSON  string `json:"report_json"`
-	ErrorDetail string `json:"error_detail"`
-}
-
-func rpc(sock string, req ipcReq) (*ipcResp, error) {
-	conn, err := net.DialTimeout("unix", sock, 5e9)
-	if err != nil {
-		return nil, fmt.Errorf("ipc dial %s: %w", sock, err)
-	}
-	defer conn.Close()
-	body, _ := json.Marshal(req)
-	lenBuf := make([]byte, 4)
-	binary.BigEndian.PutUint32(lenBuf, uint32(len(body)))
-	conn.Write(lenBuf)
-	conn.Write(body)
-	io.ReadFull(conn, lenBuf)
-	msgLen := binary.BigEndian.Uint32(lenBuf)
-	respBuf := make([]byte, msgLen)
-	io.ReadFull(conn, respBuf)
-	var resp ipcResp
-	if err := json.Unmarshal(respBuf, &resp); err != nil {
-		return nil, err
-	}
-	if resp.Status != "ok" {
-		return nil, fmt.Errorf("ipc: %s", resp.ErrorDetail)
-	}
-	return &resp, nil
-}
-
-// 枚举（与 internal/storage/delete_reason.go 保持一致）
-const (
-	DRMergeDup      = "merge_dup"
-	DRContradiction = "contradiction"
-	DRManual        = "manual"
-	DRRetention     = "retention"
-	DRUnknown       = "unknown"
-)
-
-// Normalize 把 free-form reason 归一到枚举（与 storage.NormalizeDeleteReason 同规则）。
-func Normalize(reason string) string {
-	r := strings.ToLower(strings.TrimSpace(reason))
-	if r == "" {
-		return DRUnknown
-	}
-	switch {
-	case strings.HasPrefix(r, "batch:"):
-		return DRUnknown
-	case strings.Contains(r, "manual"), strings.Contains(r, "用户"),
-		strings.Contains(r, "user"), strings.Contains(r, "feedback"),
-		strings.Contains(r, "human"), strings.Contains(r, "人工"):
-		return DRManual
-	case strings.Contains(r, "dedup"), strings.Contains(r, "wording"),
-		strings.Contains(r, "duplicate"), strings.Contains(r, "merged"),
-		strings.Contains(r, "merge"):
-		return DRMergeDup
-	case strings.Contains(r, "conflict"), strings.Contains(r, "contradict"),
-		strings.Contains(r, "consolidate"):
-		return DRContradiction
-	case strings.Contains(r, "auto_forget"), strings.Contains(r, "ephemeral"),
-		strings.Contains(r, "fragment"), strings.Contains(r, "expire"),
-		strings.Contains(r, "retention"), strings.Contains(r, "过期"),
-		strings.Contains(r, "自动"):
-		return DRRetention
-	default:
-		return DRUnknown
-	}
-}
-
-type deletedRow struct {
-	ID           string `json:"id"`
-	DeleteReason string `json:"delete_reason"`
-}
-
-// loadTombstoneReasons 从 sqlite tombstones 表读取 original_id → reason 映射。
-// 文件不存在/表不存在 ⇒ 空映射（全部落 unknown）。
-func loadTombstoneReasons(path string) (map[string]string, error) {
-	out := map[string]string{}
-	if path == "" {
-		return out, nil
-	}
-	if _, err := os.Stat(path); err != nil {
-		return out, nil // 无 tombstone 库 ⇒ 尽力判定为 0，全 unknown
-	}
-	// 复用系统 sqlite3 CLI 最简读法（避免 CGO 依赖）；库通常只在 SQLite 后端写入。
-	// 生产 LanceDB 后端 tombstones 表是空（软删直接写 memories.is_deleted），
-	// 故此处判不出是常态 —— 符合「判不出的写 unknown」。
-	return out, nil
-}
-
-func main() {
-	sock := flag.String("socket", "/tmp/zhiyi-ipc.sock", "rust sidecar unix socket")
-	tombstones := flag.String("tombstones", "", "可选：sqlite tombstones 库路径（尽力判定用）")
-	apply := flag.Bool("apply", false, "真正写库（默认 false = dry-run；未经终审禁止 true）")
-	flag.Parse()
-
-	resp, err := rpc(*sock, ipcReq{Type: "lancedb_scan_deleted"})
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "scan_deleted 失败:", err)
-		os.Exit(1)
-	}
-	var rows []deletedRow
-	if err := json.Unmarshal([]byte(resp.ReportJSON), &rows); err != nil {
-		fmt.Fprintln(os.Stderr, "unmarshal 失败:", err)
-		os.Exit(1)
-	}
-
-	tombReasons, _ := loadTombstoneReasons(*tombstones)
-	N := len(rows)
-
-	// 分类：存量已回填（非空 reason）跳过；未回填的按 tombstone 尽力判定，判不出 unknown。
-	hist := map[string]int{}
-	skipFilled := 0
-	toWrite := map[string]string{} // id -> reason
-	for _, r := range rows {
-		if r.DeleteReason != "" {
-			skipFilled++ // 已回填，跳过
-			continue
-		}
-		reason := DRUnknown
-		if tr, ok := tombReasons[r.ID]; ok && tr != "" {
-			reason = Normalize(tr)
-		}
-		toWrite[r.ID] = reason
-		hist[reason]++
-	}
-
-	fmt.Printf("已删除行总数 N = %d\n", N)
-	fmt.Printf("  已有 delete_reason（跳过） = %d\n", skipFilled)
-	fmt.Printf("  待回填 = %d\n", len(toWrite))
-	fmt.Println("── delete_reason 直方图（value→行数，仅待回填）──")
-	order := []string{DRMergeDup, DRContradiction, DRManual, DRRetention, DRUnknown}
-	keys := make([]string, 0, len(hist))
-	for k := range hist {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, k := range order {
-		fmt.Printf("[%s] %d\n", k, hist[k])
-	}
-
-	if *apply {
-		if len(toWrite) == 0 {
-			fmt.Println("apply: 无可回填行（全部已回填或已删除行为空）。")
-		} else {
-			fmt.Printf("apply: 将逐条 Update %d 行 delete_reason（id IN ... 分批）。—— 未经终审禁止。\n", len(toWrite))
-			// 实际写入走 lancedb_update（每 id 一条，带 delete_reason + is_deleted 保持 true）。
-			// 实现：对每 id 发 lancedb_update fields=[{column:delete_reason,value:'<reason>'}]
-			// 注意：**只写 delete_reason，不碰其它字段**（禁改已删除记录其它字段）。
-			var wrote int64
-			for id, reason := range toWrite {
-				fields := fmt.Sprintf(`[{"column":"delete_reason","value":"'%s'"}]`, reason)
-				r, err := rpc(*sock, ipcReq{Type: "lancedb_update", Table: "memories", ID: id, Fields: fields})
-				_ = r
-				if err != nil {
-					fmt.Fprintf(os.Stderr, "update %s 失败: %v\n", id, err)
-					continue
-				}
-				wrote++
-			}
-			fmt.Printf("apply: 已写 %d 行 delete_reason。\n", wrote)
-		}
-	} else {
-		fmt.Println("(dry-run) 未写库。输出须先经小怡终审，批准后才可 --apply。")
-	}
-}

go/cmd/fix_timestamps/main.go

@@ -1,110 +0,0 @@
-// fix_timestamps — 修复 LanceDB 中 epoch-0 时间戳的记忆
-// 用法: go run cmd/fix_timestamps/main.go
-package main
-
-import (
-	"encoding/binary"
-	"encoding/json"
-	"fmt"
-	"log"
-	"net"
-	"os"
-	"time"
-)
-
-const socketPath = "/tmp/zhiyi-ipc.sock"
-
-type MemoryRecord struct {
-	ID        string `json:"id"`
-	Content   string `json:"content"`
-	CreatedAt string `json:"created_at"`
-	UpdatedAt string `json:"updated_at"`
-}
-
-// 发 IPC 请求
-func ipcCall(req interface{}) ([]byte, error) {
-	conn, err := net.DialTimeout("unix", socketPath, 5*time.Second)
-	if err != nil {
-		return nil, fmt.Errorf("dial: %w", err)
-	}
-	defer conn.Close()
-
-	data, _ := json.Marshal(req)
-	buf := make([]byte, 4)
-	binary.BigEndian.PutUint32(buf, uint32(len(data)))
-	if _, err := conn.Write(buf); err != nil {
-		return nil, err
-	}
-	if _, err := conn.Write(data); err != nil {
-		return nil, err
-	}
-
-	respLenBuf := make([]byte, 4)
-	if _, err := conn.Read(respLenBuf); err != nil {
-		return nil, err
-	}
-	n := binary.BigEndian.Uint32(respLenBuf)
-	resp := make([]byte, n)
-	conn.Read(resp)
-	return resp, nil
-}
-
-// 批量更新字段
-func ipcUpdate(id, field, value string) error {
-	req := map[string]interface{}{
-		"cmd":   "lancedb_update",
-		"id":    id,
-		"table": "memories",
-		"fields": []map[string]interface{}{
-			{"column": field, "value": value},
-		},
-	}
-	_, err := ipcCall(req)
-	return err
-}
-
-func main() {
-	log.SetFlags(0)
-	log.SetOutput(os.Stderr)
-
-	epochThreshold := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC)
-
-	// 查所有记忆（min_recall=0 包含所有 tier）
-	req := map[string]interface{}{
-		"cmd":        "lancedb_query",
-		"min_recall": 0,
-		"limit":      5000,
-	}
-	resp, err := ipcCall(req)
-	if err != nil {
-		log.Fatalf("查询失败: %v", err)
-	}
-
-	var memories []MemoryRecord
-	if err := json.Unmarshal(resp, &memories); err != nil {
-		log.Fatalf("解析失败: %v\n内容: %s", err, string(resp))
-	}
-
-	log.Printf("查到 %d 条记忆，开始检查时间戳...\n", len(memories))
-
-	fixed := 0
-	for _, m := range memories {
-		t, err := time.Parse(time.RFC3339, m.CreatedAt)
-		if err != nil || t.Before(epochThreshold) || t.Year() < 2024 {
-			// 用确定性派生时间（避免所有epoch-0都用同一时间）
-			// 基于 ID 哈希分配 2024-2026 之间的不同日期
-			offsetDays := int(len(m.ID) % (365 * 2)) // 0-729天
-			newTime := time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC).AddDate(0, 0, offsetDays)
-			ts := newTime.Format(time.RFC3339)
-			if err := ipcUpdate(m.ID, "created_at", ts); err != nil {
-				log.Printf("  ⚠️ 更新失败 id=%s: %v", m.ID, err)
-			} else {
-				fixed++
-				log.Printf("  ✅ 修复 id=%s created_at=%s → %s", m.ID, m.CreatedAt, ts)
-			}
-			time.Sleep(50 * time.Millisecond) // 限速
-		}
-	}
-
-	log.Printf("\n完成: 修复 %d/%d 条记忆时间戳\n", fixed, len(memories))
-}

go/cmd/split_notuseful/main.go

@@ -1,171 +0,0 @@
-// 织忆 MemoryWeave — not_useful_count 拆分迁移工具（GA-P0-1 t_718d8707）
-//
-// 背景：not_useful_count 被两种语义混写——用户人工点「没用」（feedback.go
-// MarkNotUseful）与 dedup/合并流程自动降权（core.go Dedup demote）都写同一个字段。
-// 本工具把存量 not_useful_count 按来源拆分到 human_not_useful_count /
-// dedup_downweight_count。
-//
-// 分类依据（可判 M 条）：本库**无任何 per-row 来源 provenance**——feedback 与
-// dedup 都不在行上留下可辨识标记（source 只是「哪条管道进来」，非「人点还是 dedup」）。
-// 故对存量行无法按来源判定：M=0，全部归 unknown（K=N）。apply 在 M=0 时是 no-op，
-// 不会改动任何存量数据（保守安全）。
-//
-// 用法（**dry-run 默认，apply 需显式 --apply，且须经小怡终审后才允许跑**）：
-//
-//	go run ./cmd/split_notuseful --socket /tmp/zhiyi-ipc.sock            # dry-run
-//	go run ./cmd/split_notuseful --socket /tmp/zhiyi-ipc.sock --apply    # 真写（禁未审批）
-package main
-
-import (
-	"encoding/binary"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"sort"
-)
-
-type ipcReq struct {
-	Type string `json:"type"`
-}
-
-type ipcResp struct {
-	Status      string `json:"status"`
-	ReportJSON  string `json:"report_json"`
-	ErrorDetail string `json:"error_detail"`
-}
-
-func rpc(sock string, req ipcReq) (*ipcResp, error) {
-	conn, err := net.DialTimeout("unix", sock, 5e9)
-	if err != nil {
-		return nil, fmt.Errorf("ipc dial %s: %w", sock, err)
-	}
-	defer conn.Close()
-	body, _ := json.Marshal(req)
-	lenBuf := make([]byte, 4)
-	binary.BigEndian.PutUint32(lenBuf, uint32(len(body)))
-	conn.Write(lenBuf)
-	conn.Write(body)
-	io.ReadFull(conn, lenBuf)
-	msgLen := binary.BigEndian.Uint32(lenBuf)
-	respBuf := make([]byte, msgLen)
-	io.ReadFull(conn, respBuf)
-	var resp ipcResp
-	if err := json.Unmarshal(respBuf, &resp); err != nil {
-		return nil, err
-	}
-	if resp.Status != "ok" {
-		return nil, fmt.Errorf("ipc: %s", resp.ErrorDetail)
-	}
-	return &resp, nil
-}
-
-type row struct {
-	ID                   string `json:"id"`
-	Source               string `json:"source"`
-	Category             string `json:"category"`
-	UsefulCount          int    `json:"useful_count"`
-	NotUsefulCount       int    `json:"not_useful_count"`
-	HumanNotUsefulCount  int    `json:"human_not_useful_count"`
-	DedupDownweightCount int    `json:"dedup_downweight_count"`
-}
-
-// classifyBySource 按来源判定归属。返回 "human" / "dedup" / "unknown"。
-// 当前 schema 无 per-row 来源 provenance ⇒ 恒 unknown（M=0）。
-// 将来若某来源可明确标识「人工反馈」或「dedup 降权」，在此追加映射即可。
-func classifyBySource(_ row) string {
-	return "unknown"
-}
-
-func main() {
-	sock := flag.String("socket", "/tmp/zhiyi-ipc.sock", "rust sidecar unix socket")
-	apply := flag.Bool("apply", false, "真正写库（默认 false = dry-run；未经终审禁止 true）")
-	flag.Parse()
-
-	resp, err := rpc(*sock, ipcReq{Type: "lancedb_scan_all"})
-	if err != nil {
-		fmt.Fprintln(os.Stderr, "scan_all 失败:", err)
-		os.Exit(1)
-	}
-	var rows []row
-	if err := json.Unmarshal([]byte(resp.ReportJSON), &rows); err != nil {
-		fmt.Fprintln(os.Stderr, "unmarshal 失败:", err)
-		os.Exit(1)
-	}
-
-	var nu []row
-	for _, r := range rows {
-		if r.NotUsefulCount > 0 {
-			nu = append(nu, r)
-		}
-	}
-	N := len(nu)
-
-	// 分类
-	humanIDs := map[string]int{} // id -> count
-	dedupIDs := map[string]int{} // id -> count
-	unknownIDs := map[string]int{}
-	for _, r := range nu {
-		switch classifyBySource(r) {
-		case "human":
-			humanIDs[r.ID] = r.NotUsefulCount
-		case "dedup":
-			dedupIDs[r.ID] = r.NotUsefulCount
-		default:
-			unknownIDs[r.ID] = r.NotUsefulCount
-		}
-	}
-	M := len(humanIDs) + len(dedupIDs)
-	K := len(unknownIDs)
-
-	// 3 字段直方图（当前存量值分布）
-	hist := map[string]map[int]int{}
-	hist["not_useful_count"] = map[int]int{}
-	hist["human_not_useful_count"] = map[int]int{}
-	hist["dedup_downweight_count"] = map[int]int{}
-	for _, r := range rows {
-		hist["not_useful_count"][r.NotUsefulCount]++
-		hist["human_not_useful_count"][r.HumanNotUsefulCount]++
-		hist["dedup_downweight_count"][r.DedupDownweightCount]++
-	}
-
-	fmt.Printf("总行数(存活): %d\n", len(rows))
-	fmt.Printf("not_useful_count>0 待改行数 N = %d\n", N)
-	fmt.Printf("  其中可按来源判定 M = %d (human=%d dedup=%d)\n", M, len(humanIDs), len(dedupIDs))
-	fmt.Printf("  无法判定归 unknown K = %d\n", K)
-	fmt.Println("── 3 字段直方图（value→行数，仅列当前非零分布）──")
-	order := []string{"not_useful_count", "human_not_useful_count", "dedup_downweight_count"}
-	for _, f := range order {
-		m := hist[f]
-		keys := make([]int, 0, len(m))
-		for k := range m {
-			keys = append(keys, k)
-		}
-		sort.Ints(keys)
-		fmt.Printf("[%s] ", f)
-		if len(keys) == 1 && keys[0] == 0 {
-			fmt.Println("全 0（0 行非零）")
-			continue
-		}
-		parts := []string{}
-		for _, k := range keys {
-			if k == 0 {
-				continue
-			}
-			parts = append(parts, fmt.Sprintf("%d×%d", k, m[k]))
-		}
-		fmt.Println(parts)
-	}
-
-	if *apply {
-		if M == 0 {
-			fmt.Println("apply: 无可判定行（M=0），无需迁移，存量 not_useful_count 保持原样。")
-		} else {
-			fmt.Printf("apply: 将拆分 %d 行（human=%d dedup=%d）—— 需逐条 Update。\n", M, len(humanIDs), len(dedupIDs))
-		}
-	} else {
-		fmt.Println("(dry-run) 未写库。输出须先经小怡终审，批准后才可 --apply。")
-	}
-}

go/cmd/zhiyi-cli/main.go

@@ -1,600 +0,0 @@
-// 织忆 CLI — 命令行工具（零外部依赖，纯 flag 实现）
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"sort"
-	"strings"
-	"unicode/utf8"
-)
-
-// t_4fab32c1 AC2: 删除硬编码 "zhiyi-dev-key-2026" 默认值。
-// 密钥来源优先级：ZHIYI_API_KEY env → /var/lib/memoryweave/.api-key → 报错退出。
-const (
-	apiKeyDefault    = "" // 不再提供硬编码默认 key
-	apiURLDefault    = "http://localhost:7821"
-	namespaceDefault = "hermes-main"
-)
-
-// resolveAPIKey 解析 API Key：
-//  1. -key flag 显式传入（非空）
-//  2. ZHIYI_API_KEY 环境变量
-//  3. /var/lib/memoryweave/.api-key 文件（**多行格式**：注释与 `legacy:` 行跳过，
-//     取第 1 个非注释非 legacy 行 = 主密钥）
-//  4. 均无 → 返回 error，调用方退出
-//
-// 🔴 2026-09-21 修：原实现 `TrimSpace(整份文件)` 在多行 key 文件下会把
-// 「注释头 + 主密钥 + legacy 行」整块当 key 发给服务端 → 必然 401。
-func resolveAPIKey(flagKey string) (string, error) {
-	if flagKey != "" {
-		return flagKey, nil
-	}
-	if v := os.Getenv("ZHIYI_API_KEY"); v != "" {
-		return v, nil
-	}
-	if data, err := os.ReadFile("/var/lib/memoryweave/.api-key"); err == nil {
-		for _, line := range strings.Split(string(data), "\n") {
-			line = strings.TrimSpace(line)
-			if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, "legacy:") {
-				continue
-			}
-			return line, nil
-		}
-	}
-	return "", fmt.Errorf("API Key 未找到：请设 ZHIYI_API_KEY 环境变量，或将 key 写入 /var/lib/memoryweave/.api-key")
-}
-
-// ─── 全局参数 ──────────────────────────────────────────────
-
-var (
-	apiURL = flag.String("url", getEnv("ZHIYI_API_URL", apiURLDefault), "织忆 API 地址")
-	apiKey = flag.String("key", getEnv("ZHIYI_API_KEY", apiKeyDefault), "API Key")
-	ns     = flag.String("n", getEnv("ZHIYI_NAMESPACE", namespaceDefault), "命名空间")
-)
-
-// ─── 入口 ─────────────────────────────────────────────────
-
-func main() {
-	flag.Usage = usage
-	flag.Parse()
-
-	if flag.NArg() == 0 {
-		flag.Usage()
-		os.Exit(1)
-	}
-
-	// t_4fab32c1 AC2: 启动时解析 API Key，缺失则报错退出
-	// 旧版使用硬编码 "zhiyi-dev-key-2026" 作为默认值
-	apiKeyVal, err := resolveAPIKey(*apiKey)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-
-	cmd := flag.Arg(0)
-	args := flag.Args()[1:]
-
-	var runErr error
-	switch cmd {
-	case "tree":
-		runErr = runTree(args, apiKeyVal)
-	case "graph":
-		runErr = runGraph(args, apiKeyVal)
-	case "recall":
-		runErr = runRecall(args, apiKeyVal)
-	case "stats":
-		runErr = runStats(apiKeyVal)
-	case "entity":
-		runErr = runEntity(args, apiKeyVal)
-	case "help", "--help", "-h":
-		flag.Usage()
-		os.Exit(0)
-	default:
-		fmt.Fprintf(os.Stderr, "未知命令: %s\n", cmd)
-		flag.Usage()
-		os.Exit(1)
-	}
-	if runErr != nil {
-		fmt.Fprintln(os.Stderr, "Error:", runErr)
-		os.Exit(1)
-	}
-}
-
-func getEnv(key, fallback string) string {
-	if v := os.Getenv(key); v != "" {
-		return v
-	}
-	return fallback
-}
-
-func usage() {
-	fmt.Fprint(os.Stderr, `织忆 CLI — 记忆系统命令行工具
-
-用法:
-  zhiyi [全局选项] <命令> [命令参数]
-
-全局选项:
-  -url <地址>   织忆 API 地址（默认 http://localhost:7821）
-  -key <key>    API Key（默认 ZHIYI_API_KEY 环境变量）
-  -n <ns>       命名空间（默认 hermes-main）
-
-命令:
-  tree               树形展示记忆结构（按 category 分组）
-  graph [实体]       ASCII 渲染 ego-network 图谱（省略实体自动取 Top-1）
-  recall <query>     语义搜索，返回 top-10 结果
-  stats              显示系统统计（记忆数、蒸馏状态等）
-  entity <name>      查询实体详情（出现次数、关联记忆）
-
-示例:
-  zhiyi tree
-  zhiyi graph 牧尘
-  zhiyi recall 牧尘的偏好
-  zhiyi stats
-  zhiyi entity 织忆
-`)
-}
-
-// ─── API 调用 ──────────────────────────────────────────────
-
-func apiGet(path string, v interface{}, apiKey string) error {
-	return getJSON(*apiURL+path, apiKey, v)
-}
-
-func apiPost(path string, body, v interface{}, apiKey string) error {
-	return postJSON(*apiURL+path, apiKey, body, v)
-}
-
-func getJSON(url, apiKey string, v interface{}) error {
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return err
-	}
-	req.Header.Set("X-API-Key", apiKey)
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("请求失败: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != 200 {
-		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("API %d: %s", resp.StatusCode, string(body))
-	}
-	return json.NewDecoder(resp.Body).Decode(v)
-}
-
-func postJSON(url, apiKey string, body interface{}, v interface{}) error {
-	bodyBytes, _ := json.Marshal(body)
-	req, err := http.NewRequest("POST", url, bytes.NewReader(bodyBytes))
-	if err != nil {
-		return err
-	}
-	req.Header.Set("X-API-Key", apiKey)
-	req.Header.Set("Content-Type", "application/json")
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("请求失败: %w", err)
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode != 200 {
-		body, _ := io.ReadAll(resp.Body)
-		return fmt.Errorf("API %d: %s", resp.StatusCode, string(body))
-	}
-	return json.NewDecoder(resp.Body).Decode(v)
-}
-
-// ─── 命令实现 ──────────────────────────────────────────────
-
-func runTree(args []string, apiKey string) error {
-	// 从图谱 export 获取节点（带 category），按 category 分组
-	var r struct {
-		Nodes []struct {
-			ID       string  `json:"id"`
-			Name     string  `json:"name"`
-			Type     string  `json:"type,omitempty"`
-			Category string  `json:"category,omitempty"`
-			Weight   float64 `json:"weight,omitempty"`
-		} `json:"nodes"`
-		Edges []struct {
-			Source string `json:"source"`
-			Target string `json:"target"`
-			Rel    string `json:"relation"`
-		} `json:"edges"`
-		Count struct {
-			Nodes int `json:"nodes"`
-			Edges int `json:"edges"`
-		} `json:"count"`
-	}
-	if err := apiGet(fmt.Sprintf("/api/v1/graph/export?namespace=%s&limit=500", *ns), &r, apiKey); err != nil {
-		return err
-	}
-
-	// 按 type（实体类型）分组，忽略 episode 节点
-	groups := make(map[string][]string)
-	for _, n := range r.Nodes {
-		// 过滤 episode 节点（以 ep_ 开头的是 episode ID）
-		if strings.HasPrefix(n.ID, "ep_") {
-			continue
-		}
-		cat := n.Category
-		if cat == "" {
-			cat = n.Type
-		}
-		if cat == "" || cat == "entity" {
-			cat = "概念"
-		}
-		groups[cat] = append(groups[cat], n.Name)
-	}
-
-	cats := make([]string, 0, len(groups))
-	for k := range groups {
-		cats = append(cats, k)
-	}
-	sort.Strings(cats)
-
-	fmt.Printf("🧠 织忆记忆树 [%s] (%d 节点 %d 边)\n", *ns, r.Count.Nodes, r.Count.Edges)
-	fmt.Println(strings.Repeat("─", 50))
-
-	catIcons := map[string]string{
-		"人物":        "👤",
-		"项目":        "📦",
-		"事件":        "📅",
-		"概念":        "💡",
-		"位置":        "📍",
-		"组织":        "🏢",
-		"distilled": "🔄",
-	}
-	for _, cat := range cats {
-		items := groups[cat]
-		icon := catIcons[cat]
-		if icon == "" {
-			icon = "📄"
-		}
-		fmt.Printf("\n%s %s (%d)\n", icon, cat, len(items))
-		for i, label := range items {
-			if i >= 20 {
-				fmt.Printf("  … 还有 %d 个实体\n", len(items)-20)
-				break
-			}
-			fmt.Printf("  %2d. %s\n", i+1, label)
-		}
-	}
-	return nil
-}
-
-func runGraph(args []string, apiKey string) error {
-	var entity string
-	if len(args) == 0 {
-		// 从 pagerank map 取 score 最高的非 episode 实体
-		var pr struct {
-			Pagerank map[string]float64 `json:"pagerank"`
-			Count    int                `json:"count"`
-		}
-		if err := apiGet("/api/v1/graph/pagerank", &pr, apiKey); err != nil {
-			return fmt.Errorf("获取 Top 实体失败: %w", err)
-		}
-		var topEntity string
-		var topScore float64
-		for e, s := range pr.Pagerank {
-			if !strings.HasPrefix(e, "ep_") && s > topScore {
-				topScore = s
-				topEntity = e
-			}
-		}
-		if topEntity == "" {
-			return fmt.Errorf("图谱为空，无实体")
-		}
-		entity = stripPrefix(topEntity)
-	} else {
-		entity = args[0]
-	}
-
-	type navigateResp struct {
-		Entity string `json:"entity"`
-		Count  int    `json:"count"`
-		Paths  []struct {
-			From     string  `json:"from"`
-			To       string  `json:"to"`
-			Relation string  `json:"relation"`
-			Hop      int     `json:"hop"`
-			Weight   float64 `json:"weight"`
-		} `json:"paths"`
-	}
-	var resp navigateResp
-	if err := apiPost("/api/v1/graph/navigate", map[string]interface{}{
-		"entity": entity, "max_hops": 1, "namespace": *ns,
-	}, &resp, apiKey); err != nil {
-		return fmt.Errorf("获取邻居失败: %w", err)
-	}
-
-	// 统计关系和邻居
-	neighbors := make([]string, 0)
-	seen := make(map[string]bool)
-	for _, p := range resp.Paths {
-		if p.From == entity || p.From == "n_"+entity {
-			neighbor := stripPrefix(p.To)
-			if !seen[neighbor] {
-				neighbors = append(neighbors, neighbor)
-				seen[neighbor] = true
-			}
-		} else if p.To == entity || p.To == "n_"+entity {
-			neighbor := stripPrefix(p.From)
-			if !seen[neighbor] {
-				neighbors = append(neighbors, neighbor)
-				seen[neighbor] = true
-			}
-		}
-	}
-
-	relMap := make(map[string]string)
-	for _, p := range resp.Paths {
-		if p.From == entity || p.From == "n_"+entity {
-			relMap[stripPrefix(p.To)] = p.Relation
-		} else if p.To == entity || p.To == "n_"+entity {
-			relMap[stripPrefix(p.From)] = p.Relation
-		}
-	}
-
-	printASCIIGraph(entity, neighbors, relMap)
-	return nil
-}
-
-func printASCIIGraph(center string, neighbors []string, rels map[string]string) {
-	fmt.Printf("📐 织忆图谱 — %s\n", center)
-	fmt.Println(strings.Repeat("─", 50))
-
-	if len(neighbors) == 0 {
-		fmt.Println("  (无邻居)")
-		return
-	}
-
-	// 中心节点（未使用渲染，留空用于后续扩展）
-	_ = fmt.Sprintf("        %s %s", box("center", center), color("dim", "[中心节点]"))
-
-	// 分两列最多 6 个邻居
-	sort.Strings(neighbors)
-	_ = neighbors[:len(neighbors)/2]
-
-	// 计算分支
-	fmt.Println("")
-	fmt.Printf("  ┌─── %s%s ───┐\n", color("green", "◉"), color("bright", center))
-	for i, n := range neighbors {
-		rel := rels[n]
-		relStr := ""
-		if rel != "" {
-			relStr = color("dim", "("+rel+")")
-		}
-		prefix := "  │"
-		if i < len(neighbors)-1 {
-			fmt.Printf("%s  ○ %s %s\n", prefix, color("cyan", truncate(n, 12)), relStr)
-		} else {
-			fmt.Printf("%s  ○ %s %s\n", prefix, color("cyan", truncate(n, 12)), relStr)
-		}
-	}
-	fmt.Printf("  └%s (%d 个邻居)\n", strings.Repeat("─", 20), len(neighbors))
-}
-
-func runRecall(args []string, apiKey string) error {
-	if len(args) == 0 {
-		return fmt.Errorf("用法: zhiyi recall <query>")
-	}
-	query := args[0]
-
-	var resp struct {
-		Results []struct {
-			ID       string  `json:"id"`
-			Content  string  `json:"content"`
-			Category string  `json:"category"`
-			Score    float64 `json:"score"`
-		} `json:"results"`
-		Count int `json:"count"`
-	}
-	if err := apiPost("/api/v1/recall", map[string]interface{}{
-		"query": query, "namespace": *ns, "top_k": 10,
-	}, &resp, apiKey); err != nil {
-		return err
-	}
-
-	fmt.Printf("🔍 搜索: %s (%d 结果)\n", query, resp.Count)
-	fmt.Println(strings.Repeat("─", 50))
-
-	for i, m := range resp.Results {
-		_ = scoreBar(m.Score)
-		fmt.Printf("\n[%d] %s %.3f %s\n", i+1, color("green", "●"), m.Score, color("dim", m.Category))
-		fmt.Printf("    %s\n", truncate(m.Content, 100))
-		fmt.Printf("    %s\n", color("faint", m.ID))
-	}
-	if len(resp.Results) == 0 {
-		fmt.Println("  (无结果)")
-	}
-	return nil
-}
-
-func runStats(apiKey string) error {
-	var stats struct {
-		TotalMemories  int    `json:"total_memories"`
-		TotalEpisodes  int    `json:"total_episodes"`
-		Backend        string `json:"backend"`
-		TombstoneCount int    `json:"tombstone_count"`
-	}
-	var quota struct {
-		Remaining int    `json:"remaining"`
-		Used      int    `json:"used"`
-		Limit     int    `json:"limit"`
-		Status    string `json:"status"`
-	}
-	var distStatus struct {
-		QueueLen   int `json:"queue_len"`
-		DailyUsed  int `json:"daily_used"`
-		DailyLimit int `json:"daily_limit"`
-		BatchSize  int `json:"batch_size"`
-	}
-
-	apiGet("/api/v1/stats", &stats, apiKey)
-	apiGet("/api/v1/distill/quota", &quota, apiKey)
-	apiGet("/api/v1/distill/status", &distStatus, apiKey)
-
-	barLen := 40
-	filled := 0
-	if quota.Limit > 0 {
-		filled = int(float64(barLen) * float64(quota.Used) / float64(quota.Limit))
-		if filled > barLen {
-			filled = barLen
-		}
-	}
-
-	fmt.Println("🧠 织忆系统状态")
-	fmt.Println(strings.Repeat("─", 50))
-	fmt.Printf("  📊 记忆总数:  %d (episodes: %d, backend: %s)\n", stats.TotalMemories, stats.TotalEpisodes, stats.Backend)
-	fmt.Printf("  🗑️  墓碑:     %d\n", stats.TombstoneCount)
-	fmt.Printf("  ⚙️  蒸馏队列:  %d 条\n", distStatus.QueueLen)
-	fmt.Println("")
-	fmt.Printf("  📈 蒸馏配额 [%-*s] %d/%d (%s)\n",
-		barLen, strings.Repeat("█", filled)+strings.Repeat("░", barLen-filled),
-		quota.Used, quota.Limit, quota.Status)
-
-	return nil
-}
-
-func runEntity(args []string, apiKey string) error {
-	if len(args) == 0 {
-		return fmt.Errorf("用法: zhiyi entity <name>")
-	}
-	entity := args[0]
-
-	// 从 navigate 获取证据数量（并发）
-	type navResp struct {
-		Entity string `json:"entity"`
-		Count  int    `json:"count"`
-	}
-	var (
-		evCh chan navResp
-		mrCh chan struct {
-			Results []struct {
-				ID      string `json:"id"`
-				Content string `json:"content"`
-			} `json:"results"`
-		}
-	)
-
-	evCh = make(chan navResp, 1)
-	mrCh = make(chan struct {
-		Results []struct {
-			ID      string `json:"id"`
-			Content string `json:"content"`
-		} `json:"results"`
-	}, 1)
-
-	// 并发请求（navigate 和 recall 都用 POST）
-	go func() {
-		var nav navResp
-		type navPostReq struct {
-			Entity    string `json:"entity"`
-			MaxHops   int    `json:"max_hops"`
-			Namespace string `json:"namespace"`
-		}
-		if err := postJSON(*apiURL+"/api/v1/graph/navigate", apiKey, navPostReq{entity, 1, *ns}, &nav); err == nil {
-			evCh <- nav
-		} else {
-			evCh <- navResp{}
-		}
-	}()
-	go func() {
-		var recallResp struct {
-			Results []struct {
-				ID      string `json:"id"`
-				Content string `json:"content"`
-			} `json:"results"`
-		}
-		if err := apiPost("/api/v1/recall", map[string]interface{}{
-			"query": entity, "namespace": *ns, "top_k": 10,
-		}, &recallResp, apiKey); err == nil {
-			mrCh <- recallResp
-		} else {
-			mrCh <- struct {
-				Results []struct {
-					ID      string `json:"id"`
-					Content string `json:"content"`
-				} `json:"results"`
-			}{}
-		}
-	}()
-
-	nav := <-evCh
-	recallData := <-mrCh
-
-	fmt.Printf("📌 实体: %s\n", entity)
-	fmt.Println(strings.Repeat("─", 50))
-	fmt.Printf("  🔢 邻居数量: %d\n", nav.Count)
-	fmt.Printf("  📄 关联记忆: %d 条\n", len(recallData.Results))
-	if len(recallData.Results) > 0 {
-		fmt.Println("")
-		for i, m := range recallData.Results {
-			if i >= 10 {
-				fmt.Printf("  … 还有 %d 条\n", len(recallData.Results)-10)
-				break
-			}
-			fmt.Printf("  [%d] %s\n", i+1, truncate(m.Content, 80))
-		}
-	}
-	return nil
-}
-
-// ─── 辅助函数 ──────────────────────────────────────────────
-
-func truncate(s string, max int) string {
-	if utf8.RuneCountInString(s) <= max {
-		return s
-	}
-	r := []rune(s)
-	return string(r[:max-1]) + "…"
-}
-
-// stripPrefix removes the "n_" prefix from entity names if present
-func stripPrefix(s string) string {
-	if strings.HasPrefix(s, "n_") {
-		return s[2:]
-	}
-	return s
-}
-
-func scoreBar(score float64) string {
-	n := int(score * 10)
-	if n > 10 {
-		n = 10
-	}
-	return strings.Repeat("█", n) + strings.Repeat("░", 10-n)
-}
-
-// ANSI 颜色
-func color(c, s string) string {
-	m := map[string]string{
-		"green":  "\033[32m",
-		"cyan":   "\033[36m",
-		"dim":    "\033[2m",
-		"bright": "\033[1m",
-		"faint":  "\033[2m",
-	}
-	magenta := "\033[35m"
-	reset := "\033[0m"
-	if col, ok := m[c]; ok {
-		return col + s + reset
-	}
-	if c == "magenta" {
-		return magenta + s + reset
-	}
-	return s
-}
-
-func box(style, s string) string {
-	switch style {
-	case "center":
-		return "◉ " + s
-	}
-	return s
-}

go/cmd/zhiyid/main.go

@@ -11,7 +11,6 @@ import (
 	"time"
 
 	"github.com/xiaoxue/memoryweave/internal/api"
-	"github.com/xiaoxue/memoryweave/internal/storage"
 )
 
 func main() {
@@ -20,19 +19,12 @@ func main() {
 		port = "7821"
 	}
 
-	// t_4fab32c1 AC1: 监听地址可配，默认 127.0.0.1（仅本机）
-	// 旧代码写死 0.0.0.0，局域网内任何机器均可访问记忆库 API。
-	bind := os.Getenv("ZHIYI_BIND")
-	if bind == "" {
-		bind = "127.0.0.1"
-	}
-
 	srv := &http.Server{
-		Addr:         bind + ":" + port,
+		Addr:         "0.0.0.0:" + port,
 		Handler:      api.NewServer(),
-		ReadTimeout:  30 * time.Second,
-		WriteTimeout: 60 * time.Second, // full consolidation takes ~15s, need headroom
-		IdleTimeout:  120 * time.Second,
+		ReadTimeout:  10 * time.Second,
+		WriteTimeout: 10 * time.Second,
+		IdleTimeout:  60 * time.Second,
 	}
 
 	// 优雅关闭
@@ -42,8 +34,6 @@ func main() {
 		<-sigCh
 
 		log.Println("[zhiyid] 收到关闭信号，正在退出...")
-		// 累积延迟更新：把最后一个窗口的召回元数据落盘（防止统计增量丢失）
-		storage.StopRecallWriteBuffer()
 		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 		if err := srv.Shutdown(ctx); err != nil {
@@ -51,8 +41,7 @@ func main() {
 		}
 	}()
 
-	// t_4fab32c1 AC1: 日志输出实际绑定的地址
-	log.Printf("[zhiyid] 织忆 MemoryWeave 启动 — 绑定 %s:%s", bind, port)
+	log.Printf("[zhiyid] 织忆 MemoryWeave 启动 — 端口 %s", port)
 	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
 		log.Fatalf("[zhiyid] 启动失败: %v", err)
 	}

go/go.mod

@@ -1,31 +1,19 @@
 module github.com/xiaoxue/memoryweave
 
-go 1.25.0
+go 1.23.0
 
-require (
-	github.com/gorilla/websocket v1.5.3
-	github.com/prometheus/client_golang v1.23.2
-	modernc.org/sqlite v1.59.0
-)
+toolchain go1.23.5
 
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/google/uuid v1.6.0 // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/kylelemons/godebug v1.1.0 // indirect
-	github.com/mattn/go-isatty v0.0.24 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/ncruces/go-strftime v1.0.0 // indirect
+	github.com/prometheus/client_golang v1.23.2 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
 	github.com/prometheus/common v0.66.1 // indirect
 	github.com/prometheus/procfs v0.16.1 // indirect
-	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	go.yaml.in/yaml/v2 v2.4.2 // indirect
-	golang.org/x/sys v0.47.0 // indirect
+	golang.org/x/sys v0.35.0 // indirect
 	google.golang.org/protobuf v1.36.8 // indirect
-	modernc.org/libc v1.75.7 // indirect
-	modernc.org/mathutil v1.7.1 // indirect
-	modernc.org/memory v1.12.1 // indirect
 )

go/go.sum

@@ -2,37 +2,10 @@ github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
-github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3 h1:LMLX+LgTNWpfvCBdFebv6EsYotImrt/Ppc5cXIriCSo=
-github.com/google/pprof v0.0.0-20260802141513-ef3492d7dac3/go.mod h1:jl5iWTm0/hd5PjEYEOuwAJ57L/CibdZfrqZ5XA5GrCk=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
-github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
-github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
-github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
-github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
-github.com/mattn/go-isatty v0.0.24 h1:tGZZoVgT/KiqK1c8ocVLeDS8BSWMRd47J3Lbz7vsReI=
-github.com/mattn/go-isatty v0.0.24/go.mod h1:nMCL3Zebbrt45jsMDgnfIwz6ydEQApk5oEI3HqDio6A=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
-github.com/ncruces/go-strftime v1.0.0 h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w=
-github.com/ncruces/go-strftime v1.0.0/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
 github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
 github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
@@ -41,56 +14,10 @@ github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9Z
 github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
 github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
 github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
-github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
-github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
-github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
-github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
-go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
 go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
-golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk=
-golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40=
-golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek=
-golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
-golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
-golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE=
-golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk=
+golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
+golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
 google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-modernc.org/cc/v4 v4.29.2 h1:h6+9ciCnPKutf4I03CvheAvDLX7+IHlqR6Iy6J+cgd8=
-modernc.org/cc/v4 v4.29.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI=
-modernc.org/ccgo/v4 v4.35.0 h1:F+TUsmw09QxLzmi3aeYYGxjAXarmZaKgj3mKQHNaA8w=
-modernc.org/ccgo/v4 v4.35.0/go.mod h1:qrVGs9S3Sr2Ztcg9ve+kTAYMp5a3YvWjo+SoN06kJ5I=
-modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM=
-modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU=
-modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
-modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
-modernc.org/gc/v3 v3.1.5 h1:21ldfPfRYE31Tb7B3mwAK8gy1AxP4+dKjrOQPfqakoc=
-modernc.org/gc/v3 v3.1.5/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY=
-modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
-modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
-modernc.org/libc v1.75.7 h1:o3DTP9/0p9pKmY2WCKQaySW6wIiZhNM7wc2lUoyhfew=
-modernc.org/libc v1.75.7/go.mod h1:bO5o2ztHxBb2rjz0PgdHN0sSMw57CgxGFLZ3Qd/QpVQ=
-modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
-modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
-modernc.org/memory v1.12.1 h1:nFMiWrpStgZczNl6XI9GnIk/rWhYIyHGUaR04pGbp9g=
-modernc.org/memory v1.12.1/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
-modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg=
-modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
-modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
-modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
-modernc.org/sqlite v1.59.0 h1:X1es1GpqBlS/5T+vbM4HLUdaa8OtQx468DF2vrx+38A=
-modernc.org/sqlite v1.59.0/go.mod h1:+paeT2A3iPRHkQDwG7oA6Tk0zQd5woMEI8q7orfry8k=
-modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
-modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
-modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
-modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=

go/integration_test.go

@@ -19,16 +19,7 @@ import (
 
 var testServer http.Handler
 
-// testAPIKey 测试专用密钥。
-//
-// 2026-09-22：P0 安全（d026739）改为「密钥强制 + 去硬编码回落」后，集成测试原用的
-// 旧值 zhiyi-dev-key-2026 既非 env 也非 keyfile primary ⇒ 7 处请求全 401（4 个测试红）。
-// 测试自备 env key：auth 的 loadKeys() 里 env(API_KEY) 优先于 keyfile，
-// 因此既不依赖、也不触碰生产 keyfile（apiKey != "" 时不会走生成分支）。
-const testAPIKey = "test-key-integration-20260922"
-
 func TestMain(m *testing.M) {
-	os.Setenv("API_KEY", testAPIKey)
 	testServer = api.NewServer()
 	os.Exit(m.Run())
 }
@@ -44,7 +35,7 @@ func TestIntegration_FullPipeline(t *testing.T) {
 	}
 	header := map[string]string{
 		"Content-Type": "application/json",
-		"X-API-Key":    testAPIKey,
+		"X-API-Key":    "zhiyi-dev-key-2026",
 	}
 
 	// Step 1: 提交记忆
@@ -137,7 +128,7 @@ func TestIntegration_GraphFlow(t *testing.T) {
 	h := testServer
 	header := map[string]string{
 		"Content-Type": "application/json",
-		"X-API-Key":    testAPIKey,
+		"X-API-Key":    "zhiyi-dev-key-2026",
 	}
 
 	// Graph stats
@@ -168,7 +159,7 @@ func TestIntegration_AgentRegisterFlow(t *testing.T) {
 	h := testServer
 	header := map[string]string{
 		"Content-Type": "application/json",
-		"X-API-Key":    testAPIKey,
+		"X-API-Key":    "zhiyi-dev-key-2026",
 	}
 
 	// Register
@@ -210,7 +201,7 @@ func TestEdge_EmptyCommit(t *testing.T) {
 	body := map[string]interface{}{"agent_id": "", "content": ""}
 	req := httptest.NewRequest("POST", "/api/v1/commit", bytesBody(body))
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-API-Key", testAPIKey)
+	req.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
 	w := httptest.NewRecorder()
 	h.ServeHTTP(w, req)
 
@@ -256,7 +247,7 @@ func TestEdge_LargePayload(t *testing.T) {
 	}
 	req := httptest.NewRequest("POST", "/api/v1/commit", bytesBody(body))
 	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-API-Key", testAPIKey)
+	req.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
 	w := httptest.NewRecorder()
 	h.ServeHTTP(w, req)
 
@@ -284,7 +275,7 @@ func TestEdge_ConcurrentCommits(t *testing.T) {
 			}
 			req := httptest.NewRequest("POST", "/api/v1/commit", bytesBody(body))
 			req.Header.Set("Content-Type", "application/json")
-			req.Header.Set("X-API-Key", testAPIKey)
+			req.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
 			w := httptest.NewRecorder()
 			h.ServeHTTP(w, req)
 			if w.Code != 201 {
@@ -302,7 +293,7 @@ func TestEdge_ConcurrentCommits(t *testing.T) {
 }
 
 func TestEdge_GapDetectionThreshold(t *testing.T) {
-	gd := selfoptimize.NewGapDetector(nil, nil)
+	gd := selfoptimize.NewGapDetector()
 
 	// 2 misses — no gap
 	if gap := gd.RecordMiss("test"); gap != nil {
@@ -329,7 +320,7 @@ func TestEdge_GraphEmpty(t *testing.T) {
 		t.Error("empty graph should return all zeros")
 	}
 
-	paths, err := g.Navigate("nonexistent", 2, "shared", nil)
+	paths, err := g.Navigate("nonexistent", 2, "shared")
 	if err != nil {
 		t.Errorf("navigate on empty graph should not error: %v", err)
 	}
@@ -342,11 +333,10 @@ func TestEdge_TriggersFired(t *testing.T) {
 	h := testServer
 	header := map[string]string{
 		"Content-Type": "application/json",
-		"X-API-Key":    testAPIKey,
+		"X-API-Key":    "zhiyi-dev-key-2026",
 	}
 
-	// 触发器 ID 与 routes.Triggers 一致（t1..t8 是 executor 的内部编号，不是 API ID）
-	body := map[string]string{"trigger_id": "t_decay"}
+	body := map[string]string{"trigger_id": "t1"}
 	req := httptest.NewRequest("POST", "/api/v1/triggers/fire", bytesBody(body))
 	for k, v := range header {
 		req.Header.Set(k, v)

go/internal/api/cosine.go

@@ -1,23 +0,0 @@
-package api
-
-import "math"
-
-// cosineSimilarity 计算两个向量的余弦相似度。
-// 放在 api 包根目录，让 server（蒸馏写入路径）和 routes（commit 路径）
-// 共享同一套近重复判据（>=0.98），避免两套逻辑各自漂移。
-func cosineSimilarity(a, b []float32) float64 {
-	var dot, normA, normB float64
-	n := len(a)
-	if len(b) < n {
-		n = len(b)
-	}
-	for i := 0; i < n; i++ {
-		dot += float64(a[i]) * float64(b[i])
-		normA += float64(a[i]) * float64(a[i])
-		normB += float64(b[i]) * float64(b[i])
-	}
-	if normA == 0 || normB == 0 {
-		return 0
-	}
-	return dot / math.Sqrt(normA*normB)
-}

go/internal/api/middleware/auth.go

@@ -2,8 +2,6 @@
 package middleware
 
 import (
-	"crypto/rand"
-	"encoding/hex"
 	"fmt"
 	"log"
 	"net/http"
@@ -16,19 +14,19 @@ import (
 // ─── Per-Agent 令牌桶 ────────────────────────────────────────
 
 type tokenBucket struct {
-	tokens     float64
+	tokens   float64
 	lastRefill time.Time
-	rate       float64 // tokens/sec
-	burst      float64
-	mu         sync.Mutex
+	rate     float64 // tokens/sec
+	burst    float64
+	mu       sync.Mutex
 }
 
 func newTokenBucket(rate, burst float64) *tokenBucket {
 	return &tokenBucket{
-		tokens:     burst,
+		tokens:   burst,
 		lastRefill: time.Now(),
-		rate:       rate,
-		burst:      burst,
+		rate:     rate,
+		burst:    burst,
 	}
 }
 
@@ -58,10 +56,10 @@ type AgentRateConfig struct {
 }
 
 var agentRates = map[string]AgentRateConfig{
-	"hermes":     {RecallQPS: 10, CommitQPS: 2, Burst: 20},
-	"hermes-a06": {RecallQPS: 10, CommitQPS: 2, Burst: 20},
-	"openclaw":   {RecallQPS: 10, CommitQPS: 2, Burst: 20},
-	"cron-job":   {RecallQPS: 5, CommitQPS: 1, Burst: 10},
+	"hermes":    {RecallQPS: 10, CommitQPS: 2, Burst: 20},
+	"hermes-a06":{RecallQPS: 10, CommitQPS: 2, Burst: 20},
+	"openclaw":  {RecallQPS: 10, CommitQPS: 2, Burst: 20},
+	"cron-job":  {RecallQPS: 5,  CommitQPS: 1, Burst: 10},
 }
 
 var defaultRate = AgentRateConfig{RecallQPS: 5, CommitQPS: 1, Burst: 10}
@@ -69,14 +67,14 @@ var defaultRate = AgentRateConfig{RecallQPS: 5, CommitQPS: 1, Burst: 10}
 // ─── RateLimiter ─────────────────────────────────────────────
 
 type RateLimiter struct {
-	mu           sync.Mutex
-	buckets      map[string]*tokenBucket // agentID → bucket
-	maxPerMinute int                     // 全局兜底
+	mu     sync.Mutex
+	buckets map[string]*tokenBucket // agentID → bucket
+	maxPerMinute int // 全局兜底
 }
 
 func NewRateLimiter(maxPerMinute int) *RateLimiter {
 	return &RateLimiter{
-		buckets:      make(map[string]*tokenBucket),
+		buckets:       make(map[string]*tokenBucket),
 		maxPerMinute: maxPerMinute,
 	}
 }
@@ -123,124 +121,28 @@ func init() {
 
 // ─── HTTP 中间件 ─────────────────────────────────────────────
 
-// t_4fab32c1 AC2: 密钥强制（无硬编码回落）。
-// 🔑 2026-09-21 过渡期补丁（牧尘当晚批准上线）：密钥文件为**多行**格式 ——
-//
-//	第 1 个非注释行 = 主密钥；`legacy:` 前缀行 = 过渡期兼容密钥（放行但打 DEPRECATED 日志）。
-//
-// 为什么需要 legacy：hermes 记忆插件在 **import 时**读 `ZHIYI_API_KEY`，
-//
-//	正在运行的网关不重启不会重读；另有 8 个本地脚本持旧密钥。
-//	若直接轮换值 → 瞬间打断记忆读写（recall/commit 全 401）。
-//
-// 收口条件：客户端迁移完（网关重启后）删除 key 文件里的 legacy 行。
-const keyFile = "/var/lib/memoryweave/.api-key"
-
-// parseKeys 纯解析：data=key 文件内容，envKey=环境变量值。抽出来是为了可被单测直接覆盖。
-func parseKeys(data, envKey string) (primary string, legacy []string) {
-	primary = strings.TrimSpace(envKey)
-	for _, line := range strings.Split(data, "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		if strings.HasPrefix(line, "legacy:") {
-			if k := strings.TrimSpace(strings.TrimPrefix(line, "legacy:")); k != "" {
-				legacy = append(legacy, k)
-			}
-			continue
-		}
-		if primary == "" {
-			primary = line
-		}
-	}
-	return primary, legacy
-}
-
-// loadKeys 返回 (主密钥, 过渡期兼容密钥列表)
-func loadKeys() (primary string, legacy []string) {
-	data := ""
-	if b, err := os.ReadFile(keyFile); err == nil {
-		data = string(b)
-	}
-	return parseKeys(data, os.Getenv("API_KEY"))
-}
-
-var (
-	legacyUseMu sync.Mutex
-	legacyLast  = map[string]time.Time{}
-)
-
-// noteLegacyUse 对 legacy 密钥放行做限频告警（每密钥 10 分钟一次）
-func noteLegacyUse(key string) {
-	legacyUseMu.Lock()
-	last := legacyLast[key]
-	legacyLast[key] = time.Now()
-	legacyUseMu.Unlock()
-	if time.Since(last) > 10*time.Minute {
-		shown := key
-		if len(shown) > 6 {
-			shown = shown[:6] + "…"
-		}
-		log.Printf("[auth] DEPRECATED: 放行了过渡期 legacy 密钥(%s)。请迁移调用方到主密钥，并删除 %s 的 legacy 行收口。", shown, keyFile)
-	}
-}
-
-func isLegacy(list []string, key string) bool {
-	for _, k := range list {
-		if k == key {
-			return true
-		}
-	}
-	return false
-}
-
+// Auth 认证中间件 (X-API-Key)
 func Auth(next http.Handler) http.Handler {
-	apiKey, legacyKeys := loadKeys()
+	apiKey := os.Getenv("API_KEY")
 	if apiKey == "" {
-		// 生成随机密钥并持久化（无任何可用密钥时拒绝启动或落盘随机密钥）
-		buf := make([]byte, 32)
-		if _, err := rand.Read(buf); err != nil {
-			log.Fatalf("[auth] API_KEY 未设且无法生成随机密钥: %v — 拒绝启动", err)
-		}
-		apiKey = hex.EncodeToString(buf)
-		if err := os.MkdirAll("/var/lib/memoryweave", 0700); err != nil {
-			log.Printf("[auth] WARNING: 已生成随机密钥但无法创建目录: %v — 密钥仅存于内存，重启后失效", err)
-		} else if err := os.WriteFile(keyFile, []byte(apiKey+"\n"), 0600); err != nil {
-			log.Printf("[auth] WARNING: 已生成随机密钥但写入 %s 失败: %v — 密钥仅存于内存，重启后失效", keyFile, err)
-		} else {
-			log.Printf("[auth] API_KEY 未设 — 已生成随机密钥并写入 %s (0600)。请同步给调用方（zhiyi-cli / hermes 等）。", keyFile)
-		}
-	}
-	if len(legacyKeys) > 0 {
-		log.Printf("[auth] 已加载 %d 个过渡期 legacy 密钥（放行+告警）；收口：迁移调用方后删除 %s 的 legacy 行", len(legacyKeys), keyFile)
+		apiKey = "zhiyi-dev-key-2026"
 	}
 
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// t_4fab32c1 AC3: /metrics 纳入鉴权（旧版在免鉴权白名单内，无 key 即可
-		// 读取 episode 总数/进程 RSS/队列深度等运维指标，暴露系统内部状态）。
-		// /health 保留免鉴权（供 systemd / 监控探针使用）；
-		// /static/* 和 / 保留免鉴权（Web UI 静态资源）。
-		if r.URL.Path == "/health" ||
-			strings.HasPrefix(r.URL.Path, "/static/") || r.URL.Path == "/" {
+		// /health, /metrics, /static/* 不需要认证
+		if r.URL.Path == "/health" || r.URL.Path == "/metrics" || strings.HasPrefix(r.URL.Path, "/static/") {
 			next.ServeHTTP(w, r)
 			return
 		}
 
 		key := r.Header.Get("X-API-Key")
-		if key != apiKey && !isLegacy(legacyKeys, key) {
-			// t_2d4e3b92: 统一错误体 schema — 非 2xx + {"error":{"code","message","retry_after_s"}}
-			// 此前为扁平 {"error":"..."}，调用方难以与成功体区分（曾导致把 401/429 误读为「召回 0 条」）。
+		if key != apiKey {
 			w.Header().Set("Content-Type", "application/json")
 			w.WriteHeader(401)
-			w.Write([]byte(`{"error":{"code":"unauthorized","message":"invalid or missing X-API-Key","retry_after_s":0}}`))
+			w.Write([]byte(`{"error":"unauthorized: invalid or missing X-API-Key"}`))
 			return
 		}
 
-		if key != apiKey {
-			noteLegacyUse(key) // 过渡期：legacy 密钥放行但留审计痕迹
-		}
-
 		// 提取 agent ID（从 X-Agent-ID 头或 URL 路径）
 		agentID := r.Header.Get("X-Agent-ID")
 		if agentID == "" {
@@ -254,14 +156,13 @@ func Auth(next http.Handler) http.Handler {
 		}
 
 		// Per-agent 令牌桶检查
-		// t_2d4e3b92: 统一错误体 schema — 非 2xx + {"error":{"code","message","retry_after_s"}}
 		if !GlobalLimiter.Allow(agentID, endpointType) {
 			w.Header().Set("Content-Type", "application/json")
 			w.Header().Set("Retry-After", "1")
 			w.Header().Set("X-RateLimit-Reset", fmt.Sprintf("%d", time.Now().Unix()+1))
 			w.WriteHeader(429)
 			w.Write([]byte(fmt.Sprintf(
-				`{"error":{"code":"rate_limit_exceeded","message":"rate limit exceeded for agent %s","retry_after_s":1}}`, agentID,
+				`{"error":"rate_limit_exceeded","agent":"%s","retry_after":1}`, agentID,
 			)))
 			log.Printf("[ratelimit] %s exceeded for agent %s", endpointType, agentID)
 			return
@@ -298,8 +199,7 @@ func RateLimit(maxPerMinute int) func(http.Handler) http.Handler {
 				w.Header().Set("X-RateLimit-Reset", fmt.Sprintf("%d", resetTime))
 				w.Header().Set("Content-Type", "application/json")
 				w.WriteHeader(429)
-				// t_2d4e3b92: 统一错误体 schema
-				w.Write([]byte(`{"error":{"code":"rate_limit_exceeded","message":"global rate limit exceeded","retry_after_s":60}}`))
+				w.Write([]byte(`{"error":"rate_limit_exceeded","retry_after":1}`))
 				return
 			}
 

go/internal/api/middleware/auth_error_shape_test.go

@@ -1,116 +0,0 @@
-package middleware
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-// t_2d4e3b92: 中间件失败路径必须「非 2xx + 统一错误体 schema」。
-//
-// 起因：401/429 曾返回扁平 {"error":"..."} 或 {"error":..,"agent":..,"retry_after":..}，
-// 与成功体形状不同却被调用方当成「空结果」处理 —— 实测把小怡的召回质量复算一度误导成
-// 「召回 0 条 = 真实回退」。本测试锁死形状契约。
-
-// validateUnifiedErrorBody 纯函数：校验错误体形状，返回问题列表（空 = 通过）。
-// 抽成纯函数是为了能做**反证**（喂扁平 body 必须报出问题），否则判据可能恒真。
-func validateUnifiedErrorBody(status int, body []byte, wantStatus int, wantCode string) []string {
-	var problems []string
-
-	if status == 200 {
-		problems = append(problems, "失败路径不得返回 200")
-	}
-	if wantStatus != 0 && status != wantStatus {
-		problems = append(problems, fmt.Sprintf("HTTP 状态码期望 %d，实际 %d", wantStatus, status))
-	}
-
-	var top map[string]json.RawMessage
-	if err := json.Unmarshal(body, &top); err != nil {
-		return append(problems, "错误体不是合法 JSON: "+err.Error())
-	}
-
-	raw, ok := top["error"]
-	if !ok {
-		return append(problems, "错误体缺少 error 键")
-	}
-
-	// 核心判别点：error 必须是**对象**，不是字符串 —— 这正是「统一 schema」的判据
-	var obj map[string]interface{}
-	if err := json.Unmarshal(raw, &obj); err != nil {
-		return append(problems, "error 必须是对象，实际是标量/数组: "+string(raw))
-	}
-	for _, k := range []string{"code", "message", "retry_after_s"} {
-		if _, ok := obj[k]; !ok {
-			problems = append(problems, fmt.Sprintf("error 缺少字段 %q", k))
-		}
-	}
-	if wantCode != "" {
-		if got, _ := obj["code"].(string); got != wantCode {
-			problems = append(problems, fmt.Sprintf("error.code 期望 %q，实际 %q", wantCode, got))
-		}
-	}
-	return problems
-}
-
-func assertUnified(t *testing.T, rec *httptest.ResponseRecorder, wantStatus int, wantCode string) {
-	t.Helper()
-	if probs := validateUnifiedErrorBody(rec.Code, rec.Body.Bytes(), wantStatus, wantCode); len(probs) > 0 {
-		t.Fatalf("错误体形状不合契约: %v | body=%s", probs, rec.Body.String())
-	}
-}
-
-// 401：缺 key
-func TestAuthMiddleware_401_UnifiedErrorBody(t *testing.T) {
-	handler := Auth(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) }))
-
-	req := httptest.NewRequest("POST", "/api/v1/recall", nil)
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	assertUnified(t, rec, 401, "unauthorized")
-}
-
-// 401：key 错误
-func TestAuthMiddleware_401_WrongKey_UnifiedErrorBody(t *testing.T) {
-	handler := Auth(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) }))
-
-	req := httptest.NewRequest("POST", "/api/v1/recall", nil)
-	req.Header.Set("X-API-Key", "definitely-wrong-key")
-	rec := httptest.NewRecorder()
-	handler.ServeHTTP(rec, req)
-
-	assertUnified(t, rec, 401, "unauthorized")
-}
-
-// 反证：喂历史扁平 body → 校验器**必须**报出问题（证明判据非恒真）
-func TestValidateUnifiedErrorBody_Negative(t *testing.T) {
-	cases := []struct {
-		name string
-		code int
-		body string
-	}{
-		{"扁平 error 字符串（修前 401 形状）", 401, `{"error":"unauthorized: invalid or missing X-API-Key"}`},
-		{"旧限流体（修前 429 形状）", 429, `{"error":"rate_limit_exceeded","agent":"a1","retry_after":1}`},
-		{"成功体混入（无 error 键）", 200, `{"results":[],"count":0}`},
-		{"error 对象缺字段", 502, `{"error":{"code":"x"}}`},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			probs := validateUnifiedErrorBody(c.code, []byte(c.body), 0, "")
-			if len(probs) == 0 {
-				t.Fatalf("反证失败：%s 未被判错 → 判据恒真", c.body)
-			}
-			t.Logf("已判错（符合预期）: %v", probs)
-		})
-	}
-}
-
-// 正例：统一 schema 必须通过（防止校验器过严，把正确形状也判错）
-func TestValidateUnifiedErrorBody_Positive(t *testing.T) {
-	ok := `{"error":{"code":"unauthorized","message":"bad key","retry_after_s":0}}`
-	if probs := validateUnifiedErrorBody(401, []byte(ok), 401, "unauthorized"); len(probs) > 0 {
-		t.Fatalf("统一 schema 被误判: %v", probs)
-	}
-}

go/internal/api/middleware/auth_keyfile_test.go

@@ -1,41 +0,0 @@
-package middleware
-
-import (
-	"testing"
-)
-
-// 行为契约（2026-09-21 过渡期密钥补丁）：
-// key 文件多行格式 —— 注释行忽略；第 1 个非注释非 legacy 行 = 主密钥；`legacy:` 行 = 过渡期兼容。
-// 若退化会出现两种生产事故之一：①主密钥读成整份文件（所有客户端 401，记忆读写全断）；
-// ②legacy 行被当成主密钥（等于没轮换）。
-// 直接覆盖生产的 parseKeys（不是复刻实现）。
-func TestParseKeysMultiLineFormat(t *testing.T) {
-	content := "# 注释行\nPRIMARYKEY123\nlegacy:oldkey456\n\n# 再来一行注释\n"
-
-	primary, legacy := parseKeys(content, "")
-	if primary != "PRIMARYKEY123" {
-		t.Fatalf("主密钥应为 PRIMARYKEY123，实际 %q", primary)
-	}
-	if len(legacy) != 1 || legacy[0] != "oldkey456" {
-		t.Fatalf("legacy 应为 [oldkey456]，实际 %v", legacy)
-	}
-
-	if p2, _ := parseKeys(content, "ENVKEY"); p2 != "ENVKEY" {
-		t.Fatalf("env 变量应优先于文件，实际 %q", p2)
-	}
-
-	if !isLegacy(legacy, "oldkey456") {
-		t.Fatal("isLegacy 应识别过渡密钥")
-	}
-	if isLegacy(legacy, "PRIMARYKEY123") {
-		t.Fatal("主密钥不应被判为 legacy")
-	}
-	if isLegacy(legacy, "") {
-		t.Fatal("空 key 绝不可被判为 legacy（否则等于无鉴权）")
-	}
-
-	// 只有注释的损坏文件 → 无主密钥（上层走"生成随机密钥"分支，而不是放行空 key）
-	if p3, l3 := parseKeys("# only comments\n", ""); p3 != "" || len(l3) != 0 {
-		t.Fatalf("纯注释文件应解析为空，实际 primary=%q legacy=%v", p3, l3)
-	}
-}

go/internal/api/middleware/cors.go

@@ -1,27 +0,0 @@
-// CORS 中间件 — 支持 Obsidian 插件从 app://obsidian.md 调用 Go API
-package middleware
-
-import (
-	"net/http"
-)
-
-const obsidianOrigin = "app://obsidian.md"
-
-// CORS 返回支持 Obsidian 的跨域中间件
-func CORS() func(http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Access-Control-Allow-Origin", obsidianOrigin)
-			w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-			w.Header().Set("Access-Control-Allow-Headers", "X-API-Key, Content-Type, Authorization")
-			w.Header().Set("Access-Control-Allow-Credentials", "true")
-
-			if r.Method == http.MethodOptions {
-				w.WriteHeader(http.StatusNoContent)
-				return
-			}
-
-			next.ServeHTTP(w, r)
-		})
-	}
-}

go/internal/api/routes/admin.go

@@ -2,15 +2,10 @@
 package routes
 
 import (
-	"context"
 	"encoding/json"
 	"fmt"
-	"log"
 	"net/http"
 	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
 	"time"
 
 	"github.com/xiaoxue/memoryweave/internal/governance"
@@ -18,13 +13,12 @@ import (
 )
 
 type AdminAPI struct {
-	LanceDB    storage.LanceDB
-	Forgetter  *governance.Forgetter
-	GraphStore governance.GraphStore // E4.3: 图谱度参与遗忘决策
+	LanceDB  storage.LanceDB
+	Forgetter *governance.Forgetter
 }
 
-func NewAdminAPI(ldb storage.LanceDB, f *governance.Forgetter, gs governance.GraphStore) *AdminAPI {
-	return &AdminAPI{LanceDB: ldb, Forgetter: f, GraphStore: gs}
+func NewAdminAPI(ldb storage.LanceDB, f *governance.Forgetter) *AdminAPI {
+	return &AdminAPI{LanceDB: ldb, Forgetter: f}
 }
 
 // DELETE /api/v1/distilled/{id}
@@ -69,49 +63,11 @@ func (aa *AdminAPI) Forget(w http.ResponseWriter, r *http.Request) {
 	forgotten := 0
 	for _, mem := range results {
 		lastAccess := parseTimeStr(mem["last_recalled_at"])
-		// GA-P0-2 (t_c6d41ac6)：衰减/遗忘只认 recall_verified_count（正反馈才是 V 值）。
-		// recall_count 已冻结（历史虚高保命来源），seen 只用于观测，不参与衰减。
-		recallCnt := intVal(mem["recall_verified_count"])
+		recallCnt := intVal(mem["recall_count"])
 		tier := strVal(mem["tier"])
-		content := strVal(mem["content"])
 
-		// 🔒 2026-09-07 修复(误删事故): episodes(原始对话)不参与遗忘
-		if cat := strVal(mem["category"]); cat == "episodes" {
-			continue
-		}
-		// 🔒 长内容保护: >200 字记忆不参与 auto 遗忘（有实质信息）
-		if len([]rune(content)) > 200 {
-			continue
-		}
-		// 2026-09-07 方案A 碎片快速道（与 server.go decay trigger 一致）:
-		// <30 字且 >20 天未访问 → 直接遗忘（碎片 recall_count 可能虚高, 绕过保命）
-		if len([]rune(content)) < 30 && time.Since(lastAccess).Hours()/24 > 20 {
-			// 🔴 2026-10-06：空 id 直接跳过（DB 里有 id/content 全空的垃圾行会命中这条快速道）；
-			// 且 SoftDelete 失败不再计数 —— 原实现失败照样 forgotten++ ⇒ 遗忘计数虚高。
-			id := strVal(mem["id"])
-			if id == "" {
-				continue
-			}
-			if err := aa.LanceDB.SoftDelete(id, "auto_forget_fragment"); err != nil {
-				log.Printf("[softdelete] failed id=%q: %v", id, err)
-				continue
-			}
-			forgotten++
-			continue
-		}
-
-		// E4.3 修复: 从 content 提取实体（而非读 namespace），取图谱最大度
-		degree := extractTopEntityDegree(content, aa.GraphStore)
-
-		if aa.Forgetter.ShouldForget(lastAccess, recallCnt, tier, degree) {
-			id := strVal(mem["id"])
-			if id == "" {
-				continue
-			}
-			if err := aa.LanceDB.SoftDelete(id, "auto_forget"); err != nil {
-				log.Printf("[softdelete] failed id=%q: %v", id, err)
-				continue
-			}
+		if aa.Forgetter.ShouldForget(lastAccess, recallCnt, tier) {
+			aa.LanceDB.SoftDelete(strVal(mem["id"]), "auto_forget")
 			forgotten++
 		}
 	}
@@ -120,199 +76,21 @@ func (aa *AdminAPI) Forget(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-// POST /api/v1/admin/purge-invalid
-// P1-1 2026-10-08: 一次性清理 id 为空的垃圾行（DB 存在 id/content/source 全空的 2 行，
-// 命中 <30 字碎片快速道 → SoftDelete("") 被 Rust 拒绝 → 每轮刷错误日志 + 遗忘计数虚高）。
-// 这些行无 id 无法按 id 软删，只能按 id=” 条件一次性软删（is_deleted=true）。
-// ⚠️ 由验收/决策者按需调用（本实现不自动触发），本端点只提供能力 + 返回受影响行数。
-func (aa *AdminAPI) PurgeInvalid(w http.ResponseWriter, r *http.Request) {
-	n, err := aa.LanceDB.PurgeInvalid()
-	if err != nil {
-		respondError(w, 500, "purge-invalid failed: "+err.Error())
-		return
-	}
-	respond(w, 200, map[string]interface{}{
-		"status": "ok", "purged": n,
-	})
-}
-
 // POST /api/v1/admin/backup
 func (aa *AdminAPI) Backup(w http.ResponseWriter, r *http.Request) {
 	timestamp := time.Now().Format("20060102-150405")
-	backupDir := fmt.Sprintf("/home/muc/backups/memoryweave/%s", timestamp)
-	dataDir := "/var/lib/memoryweave"
-	if err := os.MkdirAll(backupDir, 0755); err != nil {
-		respondError(w, 500, "mkdir failed: "+err.Error())
+	backupPath := fmt.Sprintf("/home/muc/backups/memoryweave/%s", timestamp)
+	os.MkdirAll(backupPath, 0755)
+
+	if err := aa.LanceDB.Backup(backupPath); err != nil {
+		respondError(w, 500, "backup failed: "+err.Error())
 		return
 	}
-
-	// 1. SQLite backup: graph.db
-	graphBackup := filepath.Join(backupDir, "graph.db")
-	if err := exec.Command("sqlite3", filepath.Join(dataDir, "graph.db"), ".backup "+graphBackup).Run(); err != nil {
-		respondError(w, 500, "graph.db backup failed: "+err.Error())
-		return
-	}
-
-	// 2. SQLite backup: memoryweave.db
-	mwBackup := filepath.Join(backupDir, "memoryweave.db")
-	if err := exec.Command("sqlite3", filepath.Join(dataDir, "memoryweave.db"), ".backup "+mwBackup).Run(); err != nil {
-		respondError(w, 500, "memoryweave.db backup failed: "+err.Error())
-		return
-	}
-
-	// 3. Redis BGSAVE (fire-and-forget)
-	exec.Command("redis-cli", "BGSAVE").Run()
-
-	// 4. Tar LanceDB directories (5 min timeout — 5.5GB takes ~100s)
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Minute)
-	defer cancel()
-	if err := exec.CommandContext(ctx, "tar", "czf",
-		filepath.Join(backupDir, "lance-data.tar.gz"),
-		"-C", dataDir,
-		"episodes.lance", "memories.lance", "tombstones.lance",
-	).Run(); err != nil {
-		if ctx.Err() == context.DeadlineExceeded {
-			respondError(w, 500, "lance backup timed out after 5 minutes")
-			return
-		}
-		respondError(w, 500, "lance backup failed: "+err.Error())
-		return
-	}
-
 	respond(w, 200, map[string]string{
-		"status":    "ok",
-		"path":      backupDir,
-		"timestamp": timestamp,
+		"status": "ok", "path": backupPath, "timestamp": timestamp,
 	})
 }
 
-// GET /api/v1/admin/backups — 列出可用备份
-func (aa *AdminAPI) ListBackups(w http.ResponseWriter, r *http.Request) {
-	backupRoot := "/home/muc/backups/memoryweave"
-	entries, err := os.ReadDir(backupRoot)
-	if err != nil {
-		respondError(w, 500, "read dir failed: "+err.Error())
-		return
-	}
-
-	var backups []map[string]string
-	for _, e := range entries {
-		if !e.IsDir() {
-			continue
-		}
-		ts := e.Name()
-		// 读 mtime 作为备份时间
-		info, _ := e.Info()
-		modTime := info.ModTime().Format(time.RFC3339)
-		backups = append(backups, map[string]string{
-			"timestamp":   ts,
-			"modified_at": modTime,
-		})
-	}
-
-	respond(w, 200, map[string]interface{}{
-		"backups": backups,
-		"count":   len(backups),
-	})
-}
-
-// POST /api/v1/admin/restore — 从备份恢复
-// Body: {"timestamp": "20260602-091500"}
-func (aa *AdminAPI) Restore(w http.ResponseWriter, r *http.Request) {
-	var req struct {
-		Timestamp string `json:"timestamp"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Timestamp == "" {
-		respondError(w, 400, "timestamp required")
-		return
-	}
-
-	backupDir := fmt.Sprintf("/home/muc/backups/memoryweave/%s", req.Timestamp)
-	if _, err := os.Stat(backupDir); os.IsNotExist(err) {
-		respondError(w, 404, "backup not found: "+req.Timestamp)
-		return
-	}
-
-	dataDir := "/var/lib/memoryweave"
-
-	// 1. 停止服务（先 Go 再 sidecar）
-	stop := func(svc string) error {
-		out, err := exec.Command("systemctl", "--user", "stop", svc).CombinedOutput()
-		if err != nil {
-			return fmt.Errorf("%s: %s", svc, string(out))
-		}
-		return nil
-	}
-	if err := stop("zhiyid.service"); err != nil {
-		respondError(w, 500, "stop zhiyid failed: "+err.Error())
-		return
-	}
-	if err := stop("zhiyi-sidecar.service"); err != nil {
-		respondError(w, 500, "stop sidecar failed: "+err.Error())
-		return
-	}
-	// 等进程退出
-	time.Sleep(2 * time.Second)
-
-	// 2. 清理旧数据（lances）
-	lanceTables := []string{"episodes.lance", "memories.lance", "tombstones.lance"}
-	for _, t := range lanceTables {
-		p := filepath.Join(dataDir, t)
-		os.RemoveAll(p + ".table")
-		os.RemoveAll(p)
-	}
-
-	// 3. 解压 LanceDB tar
-	tarPath := filepath.Join(backupDir, "lance-data.tar.gz")
-	if _, err := os.Stat(tarPath); err == nil {
-		cmd := exec.Command("tar", "xzf", tarPath, "-C", dataDir)
-		cmd.Dir = dataDir
-		if out, err := cmd.CombinedOutput(); err != nil {
-			respondError(w, 500, "tar extract failed: "+string(out))
-			aa.startServices()
-			return
-		}
-	}
-
-	// 4. 还原 SQLite
-	graphDst := filepath.Join(dataDir, "graph.db")
-	mwDst := filepath.Join(dataDir, "memoryweave.db")
-	if err := exec.Command("sqlite3", graphDst, ".restore "+filepath.Join(backupDir, "graph.db")).Run(); err != nil {
-		respondError(w, 500, "graph.db restore failed: "+err.Error())
-		aa.startServices()
-		return
-	}
-	if err := exec.Command("sqlite3", mwDst, ".restore "+filepath.Join(backupDir, "memoryweave.db")).Run(); err != nil {
-		respondError(w, 500, "memoryweave.db restore failed: "+err.Error())
-		aa.startServices()
-		return
-	}
-
-	// 5. 重启服务（先 sidecar 再 Go）
-	aa.startServices()
-
-	respond(w, 200, map[string]string{
-		"status":   "ok",
-		"restored": req.Timestamp,
-		"data_dir": dataDir,
-	})
-}
-
-// startServices 启动 sidecar 和 Go 服务
-func (aa *AdminAPI) startServices() {
-	exec.Command("systemctl", "--user", "start", "zhiyi-sidecar.service").Run()
-	time.Sleep(1 * time.Second)
-	exec.Command("systemctl", "--user", "start", "zhiyid.service").Run()
-	// 等待 API 就绪
-	for i := 0; i < 10; i++ {
-		time.Sleep(1 * time.Second)
-		if resp, err := http.Get("http://localhost:7821/api/v1/stats"); err == nil {
-			resp.Body.Close()
-			return
-		}
-	}
-}
-
 // GET /api/v1/admin/audit
 func (aa *AdminAPI) Audit(w http.ResponseWriter, r *http.Request) {
 	limit := 100
@@ -324,8 +102,7 @@ func (aa *AdminAPI) Audit(w http.ResponseWriter, r *http.Request) {
 	respond(w, 200, map[string]interface{}{"audit_logs": logs, "count": len(logs)})
 }
 
-// ─── 辅助函数 ───────────────────────────────────────────────────────────────
-
+// 辅助函数
 func parseTimeStr(s interface{}) time.Time {
 	if s == nil {
 		return time.Time{}
@@ -342,14 +119,10 @@ func parseTimeStr(s interface{}) time.Time {
 
 func intVal(v interface{}) int {
 	switch n := v.(type) {
-	case int:
-		return n
-	case int32:
-		return int(n)
-	case int64:
-		return int(n)
-	case float64:
-		return int(n)
+	case int:       return n
+	case int32:     return int(n)
+	case int64:     return int(n)
+	case float64:   return int(n)
 	case json.Number:
 		i, _ := n.Int64()
 		return int(i)
@@ -362,212 +135,8 @@ func strVal(v interface{}) string {
 		return ""
 	}
 	switch s := v.(type) {
-	case string:
-		return s
-	case json.Number:
-		return s.String()
+	case string: return s
+	case json.Number: return s.String()
 	}
 	return fmt.Sprintf("%v", v)
 }
-
-// ─── E4.3: 图谱度提取 ──────────────────────────────────────────────────────
-
-// extractTopEntityDegree 从 content 提取实体，返回图中度数最高的实体度数
-// 复用 distill/engine.go 的启发式逻辑（大写单词、中文实体、技术标记）
-func extractTopEntityDegree(content string, gs governance.GraphStore) int {
-	if content == "" || gs == nil {
-		return 0
-	}
-	seen := make(map[string]bool)
-	var candidates []string
-
-	words := strings.Fields(content)
-	for _, w := range words {
-		w = strings.Trim(w, ",.;:!?，。；：！？、\"'()（）[]【】")
-		if len(w) < 2 {
-			continue
-		}
-		// 大写字母开头的英文词（Hermes, ComfyUI, Redis 等）
-		runes := []rune(w)
-		if len(runes) >= 2 && runes[0] >= 'A' && runes[0] <= 'Z' {
-			normalized := strings.ToLower(w)
-			if !seen[normalized] && !isStopWord(normalized) {
-				seen[normalized] = true
-				candidates = append(candidates, w)
-			}
-		}
-		// 中文实体（2-20 个纯中文字符）
-		cleanChinese := stripNonChinese(w)
-		if len(cleanChinese) >= 2 && len(cleanChinese) <= 20 {
-			if !seen[cleanChinese] {
-				seen[cleanChinese] = true
-				candidates = append(candidates, cleanChinese)
-			}
-		}
-		// 技术标记（数字+字母组合或纯数字）
-		if isTechToken(w) || isAllDigits(w) {
-			if !seen[w] {
-				seen[w] = true
-				candidates = append(candidates, w)
-			}
-		}
-	}
-
-	maxDegree := 0
-	for _, entity := range candidates {
-		d := gs.GetEntityDegree(entity)
-		if d > maxDegree {
-			maxDegree = d
-		}
-	}
-	return maxDegree
-}
-
-// isStopWord 停用词表（与 distill/engine.go 保持一致）
-func isStopWord(w string) bool {
-	stops := []string{
-		"the", "and", "for", "are", "but", "not", "you", "all", "can", "had",
-		"her", "was", "one", "our", "out", "this", "that", "with", "from",
-		"your", "what", "when", "where", "which", "their", "will", "would",
-		"there", "could", "other", "into", "just", "has", "have", "were",
-		"they", "been", "more", "than",
-	}
-	for _, s := range stops {
-		if w == s {
-			return true
-		}
-	}
-	return false
-}
-
-// stripNonChinese 提取纯中文字符串
-func stripNonChinese(s string) string {
-	var result []rune
-	for _, r := range s {
-		if r >= 0x4E00 && r <= 0x9FFF {
-			result = append(result, r)
-		}
-	}
-	return string(result)
-}
-
-// isTechToken 判断是否为技术标记（数字+字母混合）
-func isTechToken(s string) bool {
-	hasDigit := false
-	hasLetter := false
-	for _, r := range s {
-		if r >= '0' && r <= '9' {
-			hasDigit = true
-		}
-		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') {
-			hasLetter = true
-		}
-	}
-	return hasDigit && hasLetter
-}
-
-// isAllDigits 判断是否全为数字
-func isAllDigits(s string) bool {
-	if len(s) == 0 {
-		return false
-	}
-	for _, r := range s {
-		if r < '0' || r > '9' {
-			return false
-		}
-	}
-	return true
-}
-
-// GET /api/v1/memories — 批量列出记忆（按时间倒序，不含向量）
-// 2026-09-21：改用全表扫描（aa.LanceDB.Scan）替代「零向量 ANN 冒充列表」。
-// 修前零向量无方向 ⇒ 只拿到存储序前 N 行再按 ns 过滤 ⇒ 列表/计数失真。
-func (aa *AdminAPI) ListMemories(w http.ResponseWriter, r *http.Request) {
-	limit := 100
-	ns := r.URL.Query().Get("namespace")
-	if l := r.URL.Query().Get("limit"); l != "" {
-		if v, err := fmt.Sscanf(l, "%d", &limit); err != nil || v != 1 || limit < 1 {
-			limit = 100
-		}
-		if limit > 1000 {
-			limit = 1000
-		}
-	}
-	results, err := aa.LanceDB.Scan(limit, ns)
-	if err != nil {
-		respondError(w, 500, "list memories: "+err.Error())
-		return
-	}
-	// 去掉向量字段，减少响应体积
-	type memoryItem struct {
-		ID         string  `json:"id"`
-		Content    string  `json:"content"`
-		Category   string  `json:"category"`
-		Namespace  string  `json:"namespace,omitempty"`
-		Importance float64 `json:"importance"`
-		CreatedAt  int64   `json:"created_at"`
-	}
-	items := make([]memoryItem, 0, len(results))
-	for _, m := range results {
-		items = append(items, memoryItem{
-			ID: m.ID, Content: m.Content, Category: m.Category,
-			Namespace: m.Namespace, Importance: m.Importance,
-			CreatedAt: m.CreatedAt.Unix(),
-		})
-	}
-	respond(w, 200, map[string]interface{}{
-		"memories": items, "count": len(items), "limit": limit,
-	})
-}
-
-// ExportMemoriesMD 导出记忆为 Markdown（P5：EverOS 式 md 真相层）
-// GET /api/v1/memories/export?namespace=hermes-main&limit=1000&format=md
-// 输出人可读的 Markdown 文档：记忆可迁移、可备份、可人工审查
-func (aa *AdminAPI) ExportMemoriesMD(w http.ResponseWriter, r *http.Request) {
-	ns := r.URL.Query().Get("namespace")
-	limit := 1000
-	if l := r.URL.Query().Get("limit"); l != "" {
-		if v, err := fmt.Sscanf(l, "%d", &limit); err != nil || v != 1 || limit < 1 {
-			limit = 1000
-		}
-		if limit > 5000 {
-			limit = 5000
-		}
-	}
-	// 2026-09-21：改用全表扫描（aa.LanceDB.Scan）替代「零向量 ANN 冒充列表」。
-	results, err := aa.LanceDB.Scan(limit, ns)
-	if err != nil {
-		respondError(w, 500, "export memories: "+err.Error())
-		return
-	}
-
-	var sb strings.Builder
-	sb.WriteString("# 织忆记忆导出\n\n")
-	sb.WriteString(fmt.Sprintf("> 导出时间: %s\n", time.Now().Format("2006-01-02 15:04:05")))
-	sb.WriteString(fmt.Sprintf("> 命名空间: %s | 条数: %d\n\n---\n\n", orDefault(ns, "all"), len(results)))
-
-	for i, m := range results {
-		sb.WriteString(fmt.Sprintf("## M%d — %s\n\n", i+1, m.ID))
-		sb.WriteString(fmt.Sprintf("- **分类**: %s\n", orDefault(m.Category, "unknown")))
-		if m.Namespace != "" {
-			sb.WriteString(fmt.Sprintf("- **命名空间**: %s\n", m.Namespace))
-		}
-		sb.WriteString(fmt.Sprintf("- **重要性**: %.2f\n", m.Importance))
-		sb.WriteString(fmt.Sprintf("- **时间**: %s\n", m.CreatedAt.Format("2006-01-02 15:04:05")))
-		sb.WriteString("\n### 内容\n\n")
-		sb.WriteString(m.Content)
-		sb.WriteString("\n\n---\n\n")
-	}
-
-	w.Header().Set("Content-Type", "text/markdown; charset=utf-8")
-	w.Header().Set("Content-Disposition", "attachment; filename=zhiyi-memories-"+time.Now().Format("20060102")+".md")
-	w.WriteHeader(200)
-	w.Write([]byte(sb.String()))
-}
-
-func orDefault(s, def string) string {
-	if s == "" {
-		return def
-	}
-	return s
-}

go/internal/api/routes/admin_forget_test.go

@@ -1,161 +0,0 @@
-// 织忆 MemoryWeave — P1-1 遗忘路径计数修复单测（t_37ac8a45, 2026-10-08）
-//
-// 目标（AC3）：SoftDelete 失败 → forgotten 不得增加（原实现失败照样 forgotten++ ⇒ 遗忘计数虚高）。
-// 量具铁律：正例（成功 → forgotten+1）与负例（失败 → forgotten 不 +1）都要有。
-package routes
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http/httptest"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/xiaoxue/memoryweave/internal/governance"
-	"github.com/xiaoxue/memoryweave/internal/models"
-)
-
-// forgetMockLance 为 Forget 计数测试提供的 LanceDB 桩：
-// GetCandidatesForForgetting 可配置候选列表；SoftDelete 可配置失败/成功。
-type forgetMockLance struct {
-	candidates    []map[string]interface{}
-	softDeleteErr error
-	deletedIDs    []string
-}
-
-func (m *forgetMockLance) InsertEpisode(agentID, namespace, content, category string) (string, error) {
-	return "ep_test", nil
-}
-func (m *forgetMockLance) GetTopByQuality(agentID string, limit int) ([]models.MemoryRecord, error) {
-	return nil, nil
-}
-func (m *forgetMockLance) Stats() (map[string]interface{}, error) {
-	return map[string]interface{}{}, nil
-}
-func (m *forgetMockLance) SoftDelete(id, reason string) error {
-	if m.softDeleteErr != nil {
-		return m.softDeleteErr
-	}
-	m.deletedIDs = append(m.deletedIDs, id)
-	return nil
-}
-func (m *forgetMockLance) PurgeInvalid() (int64, error) { return 0, nil }
-func (m *forgetMockLance) SoftDeleteBatch(table string, ids []string, updatedAt string) (int64, error) {
-	return int64(len(ids)), nil
-}
-func (m *forgetMockLance) GetVersionHistory(id string) ([]map[string]interface{}, error) {
-	return nil, nil
-}
-func (m *forgetMockLance) GetCandidatesForForgetting() ([]map[string]interface{}, error) {
-	return m.candidates, nil
-}
-func (m *forgetMockLance) GetSkillCandidates(minRecalls, limit int) ([]models.MemoryRecord, error) {
-	return nil, nil
-}
-func (m *forgetMockLance) Backup(path string) error                                { return nil }
-func (m *forgetMockLance) GetAuditLog(limit int) ([]map[string]interface{}, error) { return nil, nil }
-func (m *forgetMockLance) IncrementUseful(id string) error                         { return nil }
-func (m *forgetMockLance) IncrementNotUseful(id string) error                      { return nil }
-
-// GA-P0-1 (t_718d8707)：拆分字段
-func (m *forgetMockLance) IncrementHumanNotUseful(id string) error                 { return nil }
-func (m *forgetMockLance) AppendHitEvent(memoryID, outcome, reason string) error   { return nil }
-func (m *forgetMockLance) CountHitEvents(memoryID, outcome string, since time.Time) (int, error) { return 0, nil }
-func (m *forgetMockLance) GetHitEvents(memoryID string, limit int) ([]models.HitEvent, error)    { return nil, nil }
-func (m *forgetMockLance) IncrementDedupDownweight(id string) error                { return nil }
-func (m *forgetMockLance) UpdateMemoryContent(id, newContent, source string) error { return nil }
-func (m *forgetMockLance) InsertMemory(mem models.MemoryRecord) error              { return nil }
-func (m *forgetMockLance) Search(table string, vector []float32, topK int, namespaceFilter string) ([]models.MemoryRecord, error) {
-	return nil, nil
-}
-func (m *forgetMockLance) Scan(limit int, namespaceFilter string) ([]models.MemoryRecord, error) {
-	return nil, nil
-}
-func (m *forgetMockLance) Insert(table string, record any) error { return nil }
-func (m *forgetMockLance) Update(table, id string, fields map[string]any) error {
-	return nil
-}
-
-// fragment 构造一个命中「<30 字碎片快速道」的候选（content<30 字 + 20 天未访问）。
-func fragmentCandidate(id string) map[string]interface{} {
-	return map[string]interface{}{
-		"id":               id,
-		"content":          "短碎片", // <30 字
-		"category":         "distilled",
-		"last_recalled_at": time.Now().Add(-30 * 24 * time.Hour).Format(time.RFC3339),
-		"recall_count":     0,
-		"tier":             "normal",
-	}
-}
-
-// forgetResp 解析 Forget 响应体。
-type forgetResp struct {
-	Status    string `json:"status"`
-	Scanned   int    `json:"scanned"`
-	Forgotten int    `json:"forgotten"`
-}
-
-// callForget 构造 AdminAPI 并调用 Forget 端点，返回响应体。
-func callForget(t *testing.T, db *forgetMockLance) forgetResp {
-	t.Helper()
-	aa := NewAdminAPI(db, governance.NewForgetter(), governance.NewInMemoryGraph())
-	req := httptest.NewRequest("POST", "/api/v1/admin/forget", strings.NewReader(""))
-	w := httptest.NewRecorder()
-	aa.Forget(w, req)
-	if w.Code != 200 {
-		t.Fatalf("Forget 期望 200，实得 %d：%s", w.Code, w.Body.String())
-	}
-	var resp forgetResp
-	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
-		t.Fatalf("解析响应失败: %v", err)
-	}
-	return resp
-}
-
-// TestForget_SoftDeleteFailure_DoesNotIncrement 负例（AC3 核心）：
-// 有效 id 的候选命中碎片快速道，但 SoftDelete 失败 → forgotten 不得增加。
-// 修前：失败照样 forgotten++ ⇒ 遗忘计数虚高（每轮刷日志 + 计数失真）。
-func TestForget_SoftDeleteFailure_DoesNotIncrement(t *testing.T) {
-	db := &forgetMockLance{
-		candidates:    []map[string]interface{}{fragmentCandidate("mem_fail_1")},
-		softDeleteErr: fmt.Errorf("ipc: simulated soft delete failure"),
-	}
-	resp := callForget(t, db)
-	if resp.Forgotten != 0 {
-		t.Fatalf("SoftDelete 失败时 forgotten 不得增加，实得 %d（计数 bug 未修）", resp.Forgotten)
-	}
-	t.Logf("✓ SoftDelete 失败 → forgotten=%d（不虚增）", resp.Forgotten)
-}
-
-// TestForget_SoftDeleteSuccess_Increments 正例（量具铁律：证明量具能报阳性）：
-// 有效 id 候选 + SoftDelete 成功 → forgotten 必须 +1。
-func TestForget_SoftDeleteSuccess_Increments(t *testing.T) {
-	db := &forgetMockLance{
-		candidates: []map[string]interface{}{fragmentCandidate("mem_ok_1")},
-	}
-	resp := callForget(t, db)
-	if resp.Forgotten != 1 {
-		t.Fatalf("SoftDelete 成功时 forgotten 应 +1，实得 %d", resp.Forgotten)
-	}
-	if len(db.deletedIDs) != 1 || db.deletedIDs[0] != "mem_ok_1" {
-		t.Fatalf("SoftDelete 应被调用一次并传入 mem_ok_1，实得 %v", db.deletedIDs)
-	}
-	t.Logf("✓ SoftDelete 成功 → forgotten=%d（计数正确）", resp.Forgotten)
-}
-
-// TestForget_EmptyIDSkipped 空 id 候选直接跳过（Step 2a 守卫）：
-// id 为空（id/content/source 全空的垃圾行）→ 不计数、不调用 SoftDelete。
-func TestForget_EmptyIDSkipped(t *testing.T) {
-	db := &forgetMockLance{
-		candidates: []map[string]interface{}{fragmentCandidate("")},
-	}
-	resp := callForget(t, db)
-	if resp.Forgotten != 0 {
-		t.Fatalf("空 id 候选不得计入 forgotten，实得 %d", resp.Forgotten)
-	}
-	if len(db.deletedIDs) != 0 {
-		t.Fatalf("空 id 候选不得调用 SoftDelete，实得 %v", db.deletedIDs)
-	}
-	t.Logf("✓ 空 id 候选跳过：forgotten=%d, SoftDelete 调用 0 次", resp.Forgotten)
-}

go/internal/api/routes/auto_distill.go

@@ -12,21 +12,8 @@ import (
 // DistillEngineRef 全局蒸馏引擎引用（server.go 注入）
 var DistillEngineRef *distill.Engine
 
-// CommitMeta 2026-10-08 (Gap#2)：commit 时写入方携带的元数据，透传到蒸馏产物 MemoryRecord。
-// 集中成一个结构体而非继续加位置参数——8 个位置参数再加 2 个时，「忘记传」是必然的
-// （Gap#2 的接线缺口正是这类 bug：字段加了、没人传）。
-type CommitMeta struct {
-	Source           string   // 出处（笔记路径等）→ MemoryRecord.Source
-	EmbeddingModel   string   // 血缘 → MemoryRecord.EmbeddingModel
-	ScriptVersion    string   // 血缘 → MemoryRecord.ScriptVersion
-	Confidence       *float64 // 信任等级（写入方显式声明，不从 source 反推）；nil=未声明
-	ConfidenceSource string   // authoritative | estimated
-}
-
 // AutoDistillTrigger commit 后自动触发蒸馏流水线
-// 2026-10-08 (t_7e3577c5)：新增 embedModel/scriptVer 血缘字段透传
-// 2026-10-08 (Gap#2)：改为 CommitMeta 结构体，新增 confidence 透传
-func AutoDistillTrigger(episodeID string, content string, category string, namespace string, agentID string, meta CommitMeta) {
+func AutoDistillTrigger(episodeID string, content string, category string, namespace string, agentID string) {
 	// 1. 硬规则过滤
 	if !distill.HardRulesPass(content) {
 		return
@@ -35,16 +22,11 @@ func AutoDistillTrigger(episodeID string, content string, category string, names
 	// 2. 使用蒸馏引擎
 	if DistillEngineRef != nil {
 		DistillEngineRef.Enqueue(distill.DistillInput{
-			EpisodeID:        episodeID,
-			Content:          content,
-			Category:         distill.Category(category),
-			Namespace:        namespace,
-			AgentID:          agentID,
-			Source:           meta.Source,
-			EmbeddingModel:   meta.EmbeddingModel,
-			ScriptVersion:    meta.ScriptVersion,
-			Confidence:       meta.Confidence,
-			ConfidenceSource: meta.ConfidenceSource,
+			EpisodeID: episodeID,
+			Content:   content,
+			Category:  distill.Category(category),
+			Namespace: namespace,
+			AgentID:   agentID,
 		})
 	} else {
 		// 降级: 关键词提取
@@ -54,7 +36,6 @@ func AutoDistillTrigger(episodeID string, content string, category string, names
 			Facts:     facts,
 			Entities:  extractEntities(content),
 			Namespace: namespace,
-			Source:    meta.Source, // 2026-10-12 t_67d0279a 方案A：降级路径同样透传来源分档
 		})
 	}
 
@@ -108,8 +89,8 @@ func currentUnixMS() int64 {
 // ─── 全局引用（server.go 需要访问）─────────────────────
 
 var (
-	graphUpdater    *governance.AutoGraphUpdater
-	conflictScanner = governance.NewConflictDetector()
+	graphUpdater     *governance.AutoGraphUpdater
+	conflictScanner  = governance.NewConflictDetector()
 )
 
 func SetGraphUpdater(gu *governance.AutoGraphUpdater) {
@@ -117,8 +98,6 @@ func SetGraphUpdater(gu *governance.AutoGraphUpdater) {
 }
 
 func minLen2(a, b int) int {
-	if a < b {
-		return a
-	}
+	if a < b { return a }
 	return b
 }

go/internal/api/routes/client.go

@@ -2,10 +2,9 @@
 // Hermes / OpenClaw 的客户端库，零外部依赖
 //
 // 使用:
-//
-//	client := NewClient("http://localhost:7821", "mw-your-api-key")
-//	mid, err := client.Commit("hermes", "shared", "牧尘用 Deepin 25", "system_fact")
-//	results, err := client.Recall("牧尘系统是什么", 5)
+//   client := NewClient("http://localhost:7821", "mw-your-api-key")
+//   mid, err := client.Commit("hermes", "shared", "牧尘用 Deepin 25", "system_fact")
+//   results, err := client.Recall("牧尘系统是什么", 5)
 package routes
 
 import (

go/internal/api/routes/conflicts.go

@@ -36,7 +36,7 @@ func (ca *ConflictAPI) Resolve(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		ConflictID string `json:"conflict_id"`
 		Resolution string `json:"resolution"` // keep_left / keep_right / merge / dismiss
-		Winner     string `json:"winner"`     // id of the winning memory
+		Winner     string `json:"winner"`      // id of the winning memory
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		respondError(w, 400, "invalid body")

go/internal/api/routes/consolidation_pipe.go

@@ -4,13 +4,11 @@ package routes
 import (
 	"fmt"
 	"log"
-	"sort"
 	"strings"
 	"time"
 
 	"github.com/xiaoxue/memoryweave/internal/consolidate"
 	"github.com/xiaoxue/memoryweave/internal/governance"
-	"github.com/xiaoxue/memoryweave/internal/metrics"
 	"github.com/xiaoxue/memoryweave/internal/selfoptimize"
 	"github.com/xiaoxue/memoryweave/internal/storage"
 )
@@ -24,7 +22,7 @@ type ConsolidationPipeline struct {
 	graphUpdater *governance.AutoGraphUpdater
 	conflicts    *governance.ConflictDetector
 	// Rust IPC 路径
-	dataDir    string
+	dataDir   string
 	sqlitePath string
 }
 
@@ -43,27 +41,15 @@ func (cp *ConsolidationPipeline) SetDataDir(dataDir, sqlitePath string) {
 	cp.sqlitePath = sqlitePath
 }
 
-// Run 执行 cluster_only 模式（快速聚类，供高频调度使用）
+// Run 执行全流程
+// 优先调 Rust zhiyi-consolidate（DBSCAN + 衰减校准 + 质量回溯）
+// Rust 不可用 → 降级为 Go 启发式
+// 无论走哪条路径，最后都执行图谱维护（修剪 + PageRank）
 func (cp *ConsolidationPipeline) Run() (*ConsolidationReport, error) {
-	return cp.RunWithMode("cluster_only")
-}
-
-// RunWithMode 执行指定模式的整合流程
-// mode: "cluster_only" | "full" | "prune_only"
-// full 模式触发 LLM 质量回溯 + 衰减校准（仅低频调度使用）
-func (cp *ConsolidationPipeline) RunWithMode(mode string) (*ConsolidationReport, error) {
-	// ─── 前置检查：timestamp 合理性（防止 epoch-0 数据污染聚类结果）────────
-	if mode == "full" || mode == "cluster_only" {
-		if suspicious, total := cp.checkTimestampSanity(); suspicious > 0 {
-			log.Printf("[WARN] timestamp 检查: %d/%d 条记忆时间戳可疑（可能是 epoch-0），结果仅供参考", suspicious, total)
-		}
-	}
-
-	// ─── 尝试 Rust sidecar ───────────────────────────────────────
+	// ─── 尝试 Rust sidecar ──────────────────────────────
 	var report *ConsolidationReport
 	if cp.dataDir != "" && cp.sqlitePath != "" {
-		// 用指定模式调用 Rust sidecar
-		if rustReport, err := consolidate.Run(cp.dataDir, cp.sqlitePath, mode); err == nil {
+		if rustReport, err := consolidate.Run(cp.dataDir, cp.sqlitePath, "full"); err == nil {
 			report = &ConsolidationReport{
 				StartedAt:      time.Now(),
 				FinishedAt:     time.Now(),
@@ -71,36 +57,19 @@ func (cp *ConsolidationPipeline) RunWithMode(mode string) (*ConsolidationReport,
 				Merged:         rustReport.Clusters,
 				ConflictsFound: 0,
 				Patterns:       []string{fmt.Sprintf("decay_rates=%v", rustReport.DecayRates)},
-				GraphPruned:    0,
-				ClustersFound:  rustReport.Clusters,
-				NoisePoints:    rustReport.Noise,
-				QualityScore:   rustReport.QualityScore,
+				GraphPruned:    rustReport.Noise,
 			}
-
-			// ─── 后置检查：聚类数量下限 ─────────────────────────────
-			if rustReport.Clusters <= 1 {
-				log.Printf("[ERROR] consolidate 生成 clusters=%d（疑似 epoch-0 数据或聚类失效），结果可能无效", rustReport.Clusters)
-				report.Patterns = append(report.Patterns, fmt.Sprintf("⚠️ clusters=%d 可能异常", rustReport.Clusters))
-			}
-
 			if rustReport.Quality != nil {
 				report.Patterns = append(report.Patterns,
 					fmt.Sprintf("quality_score=%.2f low_info=%d hallucinations=%d",
 						rustReport.Quality.Score, rustReport.Quality.LowInfo, rustReport.Quality.Hallucinations))
 			}
 			log.Printf("[consolidation] Rust sidecar 完成: clusters=%d noise=%d", rustReport.Clusters, rustReport.Noise)
-
-			// Phase F: 整合完成后更新 Prometheus metrics
-			metrics.TotalMemories.Set(float64(rustReport.Clusters * 10)) // 估算
-			metrics.SyncFromDashboard(selfoptimize.Dash.Metrics())
 		} else {
 			log.Printf("[consolidation] Rust sidecar 不可用 (%v)，降级为 Go 启发式", err)
 			goReport, goErr := cp.runGoFallback()
 			if goErr != nil {
-				return nil, goErr
-			}
-			if goReport == nil {
-				return nil, fmt.Errorf("consolidation failed: both Rust sidecar and Go fallback returned nil")
+				return goReport, goErr
 			}
 			report = goReport
 		}
@@ -112,25 +81,9 @@ func (cp *ConsolidationPipeline) RunWithMode(mode string) (*ConsolidationReport,
 		report = goReport
 	}
 
-	// Phase F: 整合完成后更新总记忆数指标（通过 LanceDB stats）
-	// total_episodes 来自 Rust count_rows（真实值）；旧 sidecar 回退 episodes_cached（非总量）
-	if stats, err := cp.ldb.Stats(); err == nil {
-		if total, ok := stats["total_memories"].(float64); ok {
-			metrics.TotalMemories.Set(total)
-		}
-		if total, ok := stats["total_episodes"].(float64); ok {
-			metrics.TotalEpisodes.Set(total)
-		} else if cached, ok := stats["episodes_cached"].(float64); ok {
-			metrics.TotalEpisodes.Set(cached) // 旧 sidecar 回退，非真实总量
-		}
-	}
-	metrics.SyncFromDashboard(selfoptimize.Dash.Metrics())
-
-	// ─── 图谱后处理：修剪 + PageRank（仅 full 模式执行；cluster_only 是高频快速聚类，跳过重负载的 PageRank 防止 CPU 风暴）──
-	if mode == "full" {
-		pruned := cp.runGraphMaintenance()
-		report.GraphPruned += pruned
-	}
+	// ─── 图谱后处理：修剪 + PageRank（无论 Rust/Go 都执行）──
+	pruned := cp.runGraphMaintenance()
+	report.GraphPruned += pruned
 	report.FinishedAt = time.Now()
 	report.Duration = report.FinishedAt.Sub(report.StartedAt).String()
 
@@ -150,7 +103,10 @@ func (cp *ConsolidationPipeline) runGraphMaintenance() int {
 	// Step 2: PageRank 更新（§2.5.5 — 每次修剪后全部节点重新计算）
 	ranks := cp.graph.PageRank(0.85, 20)
 	if ranks != nil {
-		// FileGraph.PageRank 在内部已直接更新节点 PageRank 字段，无需额外持久化
+		// 写回数据库（需要 SQLite 级别的接口）
+		if sqlite, ok := cp.graph.(*governance.SQLiteGraphStore); ok {
+			sqlite.UpdatePageRanks(ranks)
+		}
 		log.Printf("[consolidation] PageRank 更新: %d nodes", len(ranks))
 	}
 
@@ -211,10 +167,7 @@ func (cp *ConsolidationPipeline) RunMerge() (int, error) {
 	return cp.mergeSimilar()
 }
 
-// mergeSimilar 合并相似记忆（相同 category + 高内容重叠 → 保留较新）
-// 2026-09-06 P1 fix: 原实现双层循环全量 O(n²) —— febc2c9 全表扫描时触发 620% CPU 风暴。
-// 改为按 category 分桶后桶内两两比较（原逻辑 catI != catJ continue 本就等价），
-// 单桶超 maxMergePerBucket 截断，总计算量 O(Σ桶²) << O(n²)。
+// mergeSimilar 合并相似记忆（向量相似度 > 0.8 → 保留最新）
 func (cp *ConsolidationPipeline) mergeSimilar() (int, error) {
 	// 获取全部 distilled 记忆
 	memories, err := cp.ldb.GetCandidatesForForgetting()
@@ -222,36 +175,23 @@ func (cp *ConsolidationPipeline) mergeSimilar() (int, error) {
 		return 0, err
 	}
 
-	const maxMergePerBucket = 500
 	merged := 0
-
-	// 按 category 分桶
-	buckets := make(map[string][]map[string]interface{})
-	for _, m := range memories {
-		cat := strVal(m["category"])
-		buckets[cat] = append(buckets[cat], m)
-	}
-
-	// 桶内两两比较（同桶才可能合并，语义与原全量双层一致）
-	for _, mems := range buckets {
-		if len(mems) > maxMergePerBucket {
-			// 单桶爆炸防护：只处理最近 maxMergePerBucket 条（created_at 倒序）
-			sort.SliceStable(mems, func(a, b int) bool {
-				return memoryInt64Val(mems[a], "created_at") > memoryInt64Val(mems[b], "created_at")
-			})
-			mems = mems[:maxMergePerBucket]
-		}
-		for i := 0; i < len(mems); i++ {
-			for j := i + 1; j < len(mems); j++ {
-				contentI := strVal(mems[i]["content"])
-				contentJ := strVal(mems[j]["content"])
-				if overlap := contentOverlap(contentI, contentJ); overlap > 0.8 {
-					// 保留较新的
-					idI := strVal(mems[i]["id"])
-					idJ := strVal(mems[j]["id"])
-					_ = cp.ldb.SoftDelete(idJ, fmt.Sprintf("merged_into_%s", idI))
-					merged++
-				}
+	// 简单启发式：相同 category + 高内容重叠 → 合并
+	for i := 0; i < len(memories); i++ {
+		for j := i + 1; j < len(memories); j++ {
+			catI := strVal(memories[i]["category"])
+			catJ := strVal(memories[j]["category"])
+			if catI != catJ {
+				continue
+			}
+			contentI := strVal(memories[i]["content"])
+			contentJ := strVal(memories[j]["content"])
+			if overlap := contentOverlap(contentI, contentJ); overlap > 0.8 {
+				// 保留较新的
+				idI := strVal(memories[i]["id"])
+				idJ := strVal(memories[j]["id"])
+				_ = cp.ldb.SoftDelete(idJ, fmt.Sprintf("merged_into_%s", idI))
+				merged++
 			}
 		}
 	}
@@ -259,21 +199,12 @@ func (cp *ConsolidationPipeline) mergeSimilar() (int, error) {
 }
 
 // Step 2: 扫描所有待解决冲突
-// 2026-09-06 P1 fix: 原注释"最近 100 条"但实际对全量做实体提取+对比 → 全表时 O(n·50)。
-// 显式按 created_at 取最近 maxConflictScan 条再扫。
 func (cp *ConsolidationPipeline) scanConflicts() (int, error) {
-	// 获取候选并按最近优先截断（created_at 倒序）
+	// 获取最近 100 条记忆
 	memories, err := cp.ldb.GetCandidatesForForgetting()
 	if err != nil {
 		return 0, err
 	}
-	const maxConflictScan = 500
-	if len(memories) > maxConflictScan {
-		sort.SliceStable(memories, func(a, b int) bool {
-			return memoryInt64Val(memories[a], "created_at") > memoryInt64Val(memories[b], "created_at")
-		})
-		memories = memories[:maxConflictScan]
-	}
 
 	count := 0
 	for i := 0; i < len(memories); i++ {
@@ -334,67 +265,6 @@ func (cp *ConsolidationPipeline) updateGraph() (int, error) {
 	return before - after, nil
 }
 
-// checkTimestampSanity 抽样检查记忆时间戳合理性（均匀抽样，不阻塞）
-// 返回 (可疑数量, 抽样总数)。epoch-0（< 2024-01-01）视为可疑。
-// 2026-09-06 P1 fix: 原实现全量拉取只为 5% 抽样 → 先截断最近 maxSanitySample
-// 条再做均匀 step 抽样，避免全量内存/IO 与排序成本。
-func (cp *ConsolidationPipeline) checkTimestampSanity() (suspicious, total int) {
-	const epochThreshold int64 = 1704067200 // 2024-01-01 00:00:00 UTC
-	const maxSanitySample = 1000
-
-	memories, err := cp.ldb.GetCandidatesForForgetting()
-	if err != nil || len(memories) == 0 {
-		return 0, 0
-	}
-
-	// 超过 maxSanitySample 时按 created_at 取最新，再均匀抽样
-	if len(memories) > maxSanitySample {
-		sort.SliceStable(memories, func(a, b int) bool {
-			return memoryInt64Val(memories[a], "created_at") > memoryInt64Val(memories[b], "created_at")
-		})
-		memories = memories[:maxSanitySample]
-	}
-
-	// 抽样最多 100 条
-	sampleSize := len(memories)
-	if sampleSize > 100 {
-		sampleSize = 100
-	}
-	step := len(memories) / sampleSize
-	if step < 1 {
-		step = 1
-	}
-
-	for i := 0; i < len(memories); i += step {
-		total++
-		ts := memoryInt64Val(memories[i], "created_at")
-		if ts > 0 && ts < epochThreshold {
-			suspicious++
-		}
-	}
-	return suspicious, total
-}
-
-// memoryInt64Val 安全取 int64（处理 string/int/float）
-func memoryInt64Val(m map[string]interface{}, key string) int64 {
-	v, ok := m[key]
-	if !ok {
-		return 0
-	}
-	switch val := v.(type) {
-	case int64:
-		return val
-	case float64:
-		return int64(val)
-	case int:
-		return int64(val)
-	case string:
-		t, _ := time.Parse(time.RFC3339, val)
-		return t.Unix()
-	}
-	return 0
-}
-
 // ─── 报告 ─────────────────────────────────────────────
 
 type ConsolidationReport struct {
@@ -405,9 +275,6 @@ type ConsolidationReport struct {
 	ConflictsFound int       `json:"conflicts_found"`
 	Patterns       []string  `json:"patterns"`
 	GraphPruned    int       `json:"graph_pruned"`
-	ClustersFound  int       `json:"clusters_found"`
-	NoisePoints    int       `json:"noise_points"`
-	QualityScore   float64   `json:"quality_score"`
 	Errors         []string  `json:"errors,omitempty"`
 }
 
@@ -444,8 +311,7 @@ func extractEntities(text string) []string {
 }
 
 func minInt2(a, b int) int {
-	if a < b {
-		return a
-	}
+	if a < b { return a }
 	return b
 }
+

go/internal/api/routes/deep_think.go

@@ -1,228 +0,0 @@
-// 织忆 MemoryWeave — 深度推理端点（人侧数据 → 三类清单）
-package routes
-
-import (
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"strconv"
-	"time"
-
-	"github.com/xiaoxue/memoryweave/internal/governance"
-)
-
-// DeepThinkRequest 深度推理请求
-type DeepThinkRequest struct {
-	AgentID string `json:"agent_id"`
-	// namespace 为空时取人侧默认命名空间
-	Namespace string `json:"namespace,omitempty"`
-	// 最大社区数（摘要开销控制）
-	MaxCommunities int `json:"max_communities,omitempty"`
-}
-
-// DeepThinkResponse 三类清单
-type DeepThinkResponse struct {
-	OK               bool            `json:"ok"`
-	AgentID          string          `json:"agent_id"`
-	Namespace        string          `json:"namespace"`
-	Profiles         []DeepThinkItem `json:"profiles"` // 画像规则（待拍板）
-	Episodes         []DeepThinkItem `json:"episodes"` // 心迹/牵挂/承诺句（已处置）
-	Signals          []DeepThinkItem `json:"signals"`  // 社区摘要（信号）
-	ConflictsPending int             `json:"conflicts_pending"`
-	LastRun          string          `json:"last_run"`
-}
-
-// DeepThinkItem 清单条目
-type DeepThinkItem struct {
-	ID         string `json:"id"`
-	Category   string `json:"category"`
-	Content    string `json:"content"`
-	Weight     string `json:"weight,omitempty"` // 社区摘要用
-	Source     string `json:"source"`           // memories | graph | community
-	RecallOnly bool   `json:"recall_only"`      // 仅 recall 时注入，不持久化
-}
-
-// HandleDeepThink POST /api/v1/deep-think
-func (a *API) HandleDeepThink(w http.ResponseWriter, r *http.Request) {
-	var req DeepThinkRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		respondError(w, 400, "decode request: "+err.Error())
-		return
-	}
-	if req.AgentID == "" {
-		respondError(w, 400, "agent_id required")
-		return
-	}
-	ns := req.Namespace
-	if ns == "" {
-		// 人侧数据统一命名空间（牧尘拍板：soulful-xiaowei，deriveNamespace 会自动加 -main 后缀 → soulful-xiaowei-main）
-		ns = deriveNamespace("soulful-xiaowei")
-	}
-	maxC := req.MaxCommunities
-	if maxC == 0 {
-		maxC = 10
-	}
-
-	now := time.Now().UTC()
-	resp := DeepThinkResponse{
-		OK:        true,
-		AgentID:   req.AgentID,
-		Namespace: ns,
-		LastRun:   now.Format(time.RFC3339),
-	}
-
-	// 1. 画像 → category=profiles
-	resp.Profiles = a.fetchCategory(ns, "profiles", 20, false)
-	// 2. 心迹/牵挂/承诺句 → category=episodes
-	episodes := a.fetchCategory(ns, "episodes", 30, false)
-	episodes = append(episodes, a.fetchCategory(ns, "cares", 15, false)...)
-	resp.Episodes = episodes
-
-	// 3. 冲突（待裁决）→ 待拍板
-	resp.ConflictsPending = 0
-	if a.ConflictDetector != nil {
-		for _, c := range a.ConflictDetector.ListActive() {
-			if c.Status == "pending" {
-				resp.ConflictsPending++
-				resp.Profiles = append(resp.Profiles, DeepThinkItem{
-					ID: c.ID, Category: "conflict", Content: c.Description,
-					Source: "conflict_detector", RecallOnly: false,
-				})
-			}
-		}
-	}
-
-	// 4. 图谱社区 → 信号
-	cds := governance.NewCommunityDiscovery(a.GraphStore)
-	communities, err := cds.Find(ns, 3)
-	if err == nil && len(communities) > 0 {
-		if len(communities) > maxC {
-			communities = communities[:maxC]
-		}
-		summaries, _ := cds.Summarize(communities, ns, 5)
-		for _, c := range summaries {
-			resp.Signals = append(resp.Signals, DeepThinkItem{
-				ID:         c.ID,
-				Category:   "community",
-				Content:    c.Summary,
-				Weight:     strconv.FormatFloat(c.Weight, 'f', 2, 64),
-				Source:     "community_discovery",
-				RecallOnly: false,
-			})
-		}
-	}
-
-	// 5. 图谱扩展（画像/牵挂/心迹 的邻接）
-	resp.Signals = append(resp.Signals, a.graphSignals(ns, resp.Profiles, resp.Episodes)...)
-
-	// 6. 写回 category=signals（异步持久化）
-	go a.persistSignals(resp)
-
-	respond(w, 200, map[string]interface{}{
-		"ok": true, "agent_id": req.AgentID, "namespace": ns,
-		"profiles": len(resp.Profiles),
-		"episodes": len(resp.Episodes),
-		"signals":  len(resp.Signals),
-		"last_run": resp.LastRun,
-	})
-}
-
-// fetchCategory 取某 category 的记忆（用零向量 search，按 importance 排序）
-func (a *API) fetchCategory(ns, cat string, limit int, recallOnly bool) []DeepThinkItem {
-	zeroVec := make([]float32, 1024)
-	results, err := a.LanceDB.Search("memories", zeroVec, limit, ns)
-	if err != nil {
-		return nil
-	}
-	var out []DeepThinkItem
-	for _, m := range results {
-		if cat != "" && m.Category != cat {
-			continue
-		}
-		out = append(out, DeepThinkItem{
-			ID: m.ID, Category: m.Category, Content: truncate(m.Content, 200),
-			Source: "memories", RecallOnly: recallOnly,
-		})
-	}
-	return out
-}
-
-// graphSignals 从图谱取画像/牵挂/心迹的邻接关系
-func (a *API) graphSignals(ns string, profiles, episodes []DeepThinkItem) []DeepThinkItem {
-	var out []DeepThinkItem
-	seen := make(map[string]bool)
-	for _, item := range append(profiles, episodes...) {
-		if item.ID == "" {
-			continue
-		}
-		paths, err := a.GraphStore.Navigate(item.ID, 2, ns, nil)
-		if err != nil {
-			continue
-		}
-		for _, p := range paths {
-			to, _ := p["to"].(string)
-			rel, _ := p["relation"].(string)
-			if to == "" || seen[to] {
-				continue
-			}
-			seen[to] = true
-			out = append(out, DeepThinkItem{
-				ID: to, Category: "graph_relation",
-				Content: fmt.Sprintf("%s → %s: %s", item.ID, to, rel),
-				Source:  "graph", RecallOnly: false,
-			})
-		}
-	}
-	return out
-}
-
-// persistSignals 把信号写回 memories（category=signals）
-// 异步：不把延迟暴露给调用方
-func (a *API) persistSignals(resp DeepThinkResponse) {
-	if len(resp.Signals) == 0 {
-		return
-	}
-	for _, s := range resp.Signals {
-		_, _ = a.LanceDB.InsertEpisode(resp.AgentID, resp.Namespace,
-			fmt.Sprintf("[信号] %s | 来源:%s", s.Content, s.Source), "signals")
-	}
-}
-
-// HandleCommunitySummarize POST /api/v1/community/summarize
-// 运行 Louvain 社区发现 + 摘要（纯 Go，不调 LLM）
-func (a *API) HandleCommunitySummarize(w http.ResponseWriter, r *http.Request) {
-	var req struct {
-		AgentID        string `json:"agent_id"`
-		Namespace      string `json:"namespace,omitempty"`
-		MaxCommunities int    `json:"max_communities,omitempty"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		respondError(w, 400, "decode request: "+err.Error())
-		return
-	}
-	ns := req.Namespace
-	if ns == "" {
-		ns = deriveNamespace("soulful-xiaowei")
-	}
-	maxC := req.MaxCommunities
-	if maxC == 0 {
-		maxC = 10
-	}
-
-	cds := governance.NewCommunityDiscovery(a.GraphStore)
-	communities, err := cds.Find(ns, 3)
-	if err != nil {
-		respondError(w, 500, "find communities: "+err.Error())
-		return
-	}
-	if len(communities) > maxC {
-		communities = communities[:maxC]
-	}
-	summaries, _ := cds.Summarize(communities, ns, 5)
-
-	respond(w, 200, map[string]interface{}{
-		"ok": true, "namespace": ns,
-		"communities": len(communities),
-		"summaries":   summaries,
-	})
-}

go/internal/api/routes/entity_index.go

@@ -1,236 +0,0 @@
-package routes
-
-import (
-	"sort"
-	"strings"
-	"sync"
-	"time"
-	"unicode"
-)
-
-// NodeVocabularyFunc 返回「节点名 → PageRank 权重」快照（通常是 graphStore.PageRank）。
-type NodeVocabularyFunc func() map[string]float64
-
-// entityCandidate 是查询串里命中的一个图谱节点。
-type entityCandidate struct {
-	Name   string // 原始拼写（用于 Navigate / 笔记匹配）
-	Weight float64
-	Runes  int
-	Pos    int
-}
-
-// EntityIndex 用图谱节点名词表把「整句自然语言」拆成候选实体（本地最长/权重匹配）。
-//
-// 背景：调用方（hermes 织忆插件）把整句用户提问直接当 entity 传给
-// /api/v1/graph/notes，NormalizeEntity 后整句匹配不到任何节点 → 0 篇笔记。
-// 服务端在这里兜底拆实体，调用方无需改动（也就无需重启 hermes 网关）。
-type EntityIndex struct {
-	load NodeVocabularyFunc
-	ttl  time.Duration
-
-	// MinNameRunes / MaxNameRunes 限定候选实体长度（rune 数）。
-	MinNameRunes int
-	MaxNameRunes int
-	// MinWeightRatio 丢掉相对 top 候选过弱的候选（压通用词噪声，如「位置」）。
-	MinWeightRatio float64
-	// Degree 返回实体在图谱里的度数（edges 计数）；nil 表示不做度数过滤。
-	Degree func(name string) int
-	// MinDegree 度数低于此值的候选判为噪声节点（如自动切词产物「一句话」）。
-	MinDegree int
-
-	mu        sync.RWMutex
-	names     map[string]entityCandidate
-	loadedAt  time.Time
-	lastTryAt time.Time
-	retryGap  time.Duration
-
-	now func() time.Time
-}
-
-// NewEntityIndex 创建实体索引；load 为 nil 时 Extract 恒返回空。
-func NewEntityIndex(load NodeVocabularyFunc) *EntityIndex {
-	return &EntityIndex{
-		load:           load,
-		ttl:            10 * time.Minute,
-		MinNameRunes:   2,
-		MaxNameRunes:   8,
-		MinWeightRatio: 0.15,
-		MinDegree:      3,
-		retryGap:       60 * time.Second,
-		now:            time.Now,
-	}
-}
-
-// Warm 在 delay 之后后台加载一次词表，避免首次兜底请求被 2.5s 的 PageRank 阻塞。
-func (e *EntityIndex) Warm(delay time.Duration) {
-	if e == nil || e.load == nil {
-		return
-	}
-	go func() {
-		if delay > 0 {
-			time.Sleep(delay)
-		}
-		e.vocabulary()
-	}()
-}
-
-// vocabulary 返回当前词表（TTL 内复用；加载失败按 retryGap 退避，永不 panic）。
-func (e *EntityIndex) vocabulary() map[string]entityCandidate {
-	if e == nil || e.load == nil {
-		return nil
-	}
-	now := e.now()
-	e.mu.RLock()
-	if len(e.names) > 0 && now.Sub(e.loadedAt) < e.ttl {
-		names := e.names
-		e.mu.RUnlock()
-		return names
-	}
-	e.mu.RUnlock()
-
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	now = e.now()
-	// 双检：可能在等锁期间已被别的请求加载好
-	if len(e.names) > 0 && now.Sub(e.loadedAt) < e.ttl {
-		return e.names
-	}
-	if !e.lastTryAt.IsZero() && now.Sub(e.lastTryAt) < e.retryGap {
-		return e.names // 退避期内：用旧词表（可能为空）但不重复打 DB
-	}
-	e.lastTryAt = now
-	raw := e.load()
-	if len(raw) == 0 {
-		return e.names
-	}
-	names := make(map[string]entityCandidate, len(raw))
-	for name, w := range raw {
-		name = strings.TrimSpace(name)
-		if name == "" {
-			continue
-		}
-		key := strings.ToLower(name)
-		if prev, ok := names[key]; !ok || w > prev.Weight {
-			names[key] = entityCandidate{Name: name, Weight: w, Runes: len([]rune(name))}
-		}
-	}
-	e.names = names
-	e.loadedAt = now
-	return names
-}
-
-// Extract 把整句拆成候选实体：取所有「是查询串子串」的节点名，按权重排序去重。
-// 返回按权重降序的实体名，最多 maxEntities 个；无命中返回 nil。
-func (e *EntityIndex) Extract(query string, maxEntities int) []string {
-	if e == nil || maxEntities <= 0 {
-		return nil
-	}
-	query = strings.TrimSpace(query)
-	if query == "" {
-		return nil
-	}
-	names := e.vocabulary()
-	if len(names) == 0 {
-		return nil
-	}
-	runes := []rune(strings.ToLower(query))
-	total := len(runes)
-	minLen, maxLen := e.MinNameRunes, e.MaxNameRunes
-	if minLen < 1 {
-		minLen = 1
-	}
-	if maxLen < minLen {
-		maxLen = minLen
-	}
-
-	// 收集所有命中：候选名必须是查询串的（区分大小写已归一为小写）子串
-	found := make(map[string]entityCandidate)
-	for i := 0; i < total; i++ {
-		limit := maxLen
-		if total-i < limit {
-			limit = total - i
-		}
-		for n := limit; n >= minLen; n-- {
-			key := string(runes[i : i+n])
-			c, ok := names[key]
-			if !ok || !hasLetter(c.Name) {
-				continue
-			}
-			if prev, dup := found[key]; !dup || c.Weight > prev.Weight {
-				c.Pos = i
-				found[key] = c
-			}
-			break // 同一位置只取最长命中，短前缀交给其他起点
-		}
-	}
-	if len(found) == 0 {
-		return nil
-	}
-	cands := make([]entityCandidate, 0, len(found))
-	for _, c := range found {
-		cands = append(cands, c)
-	}
-	sort.Slice(cands, func(i, j int) bool {
-		if cands[i].Weight != cands[j].Weight {
-			return cands[i].Weight > cands[j].Weight
-		}
-		if cands[i].Runes != cands[j].Runes {
-			return cands[i].Runes > cands[j].Runes
-		}
-		return cands[i].Pos < cands[j].Pos
-	})
-
-	top := cands[0].Weight
-	ratio := e.MinWeightRatio
-	if ratio < 0 {
-		ratio = 0
-	}
-	out := make([]string, 0, maxEntities)
-	checks := 0
-	maxChecks := maxEntities * 2
-	for _, c := range cands {
-		if top > 0 && c.Weight < top*ratio {
-			break // 已按权重降序，后面更弱
-		}
-		redundant := false
-		lc := strings.ToLower(c.Name)
-		for _, sel := range out {
-			if strings.ToLower(sel) == lc {
-				redundant = true
-				break
-			}
-			// 短名被已选长名包含（且不更强）→ 冗余，如「织忆」vs「织忆系统」
-			if strings.Contains(strings.ToLower(sel), lc) {
-				redundant = true
-				break
-			}
-		}
-		if redundant {
-			continue
-		}
-		if e.Degree != nil && checks < maxChecks {
-			checks++
-			if e.Degree(c.Name) < e.MinDegree {
-				continue // 噪声节点（自动切词产物等），不参与笔记匹配
-			}
-		}
-		out = append(out, c.Name)
-		if len(out) >= maxEntities {
-			break
-		}
-	}
-	if len(out) == 0 {
-		return nil
-	}
-	return out
-}
-
-// hasLetter 过滤纯符号/数字的节点名（图谱里有少量噪声节点）。
-func hasLetter(s string) bool {
-	for _, r := range s {
-		if unicode.IsLetter(r) {
-			return true
-		}
-	}
-	return false
-}

go/internal/api/routes/entity_index_test.go

@@ -1,166 +0,0 @@
-package routes
-
-import (
-	"reflect"
-	"testing"
-	"time"
-)
-
-func fakeVocab(m map[string]float64) (NodeVocabularyFunc, *int) {
-	calls := 0
-	return func() map[string]float64 {
-		calls++
-		return m
-	}, &calls
-}
-
-// 真实场景：hermes 织忆插件把整句提问当 entity 传过来，服务端要能拆出实体。
-func TestExtractNLSentence(t *testing.T) {
-	load, _ := fakeVocab(map[string]float64{
-		"织忆": 3.386e-06,
-		"位置": 1.510e-06,
-		"小怡": 3.134e-06,
-		"牧尘": 2.491e-06,
-	})
-	idx := NewEntityIndex(load)
-	got := idx.Extract("现在织忆recall带obsidian实体位置么", 2)
-	want := []string{"织忆", "位置"}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("got %v want %v", got, want)
-	}
-
-	// 只取 1 个时必须是权重最高的那个
-	if got := idx.Extract("现在织忆recall带obsidian实体位置么", 1); !reflect.DeepEqual(got, []string{"织忆"}) {
-		t.Fatalf("top1 got %v", got)
-	}
-}
-
-func TestExtractASCIIKeepsOriginalSpelling(t *testing.T) {
-	load, _ := fakeVocab(map[string]float64{
-		"Obsidian": 2.0e-06,
-		"CLI":      1.0e-06,
-	})
-	idx := NewEntityIndex(load)
-	got := idx.Extract("obsidian 和 cli 怎么配", 5)
-	want := []string{"Obsidian", "CLI"}
-	if !reflect.DeepEqual(got, want) {
-		t.Fatalf("got %v want %v", got, want)
-	}
-}
-
-func TestExtractDropsContainedShorterName(t *testing.T) {
-	load, _ := fakeVocab(map[string]float64{
-		"织忆系统": 3.0e-06,
-		"织忆":   2.0e-06,
-	})
-	idx := NewEntityIndex(load)
-	if got := idx.Extract("织忆系统的笔记", 5); !reflect.DeepEqual(got, []string{"织忆系统"}) {
-		t.Fatalf("got %v", got)
-	}
-}
-
-func TestExtractWeightRatioFilter(t *testing.T) {
-	load, _ := fakeVocab(map[string]float64{"织忆": 3.0e-06, "位置": 1.0e-06})
-	idx := NewEntityIndex(load)
-	if got := idx.Extract("织忆和位置", 5); len(got) != 2 {
-		t.Fatalf("默认阈值应保留两个，got %v", got)
-	}
-	idx.MinWeightRatio = 0.5
-	if got := idx.Extract("织忆和位置", 5); !reflect.DeepEqual(got, []string{"织忆"}) {
-		t.Fatalf("阈值 0.5 应只剩织忆，got %v", got)
-	}
-}
-
-func TestExtractSkipsTooShortAndNonLetterNames(t *testing.T) {
-	load, _ := fakeVocab(map[string]float64{"忆": 5.0e-06, "12": 4.0e-06})
-	idx := NewEntityIndex(load)
-	if got := idx.Extract("织忆12", 5); got != nil {
-		t.Fatalf("expected nil, got %v", got)
-	}
-}
-
-func TestExtractNoHitAndEmptyQuery(t *testing.T) {
-	load, _ := fakeVocab(map[string]float64{"织忆": 3.0e-06})
-	idx := NewEntityIndex(load)
-	if got := idx.Extract("今天天气不错", 3); got != nil {
-		t.Fatalf("expected nil, got %v", got)
-	}
-	if got := idx.Extract("   ", 3); got != nil {
-		t.Fatalf("expected nil, got %v", got)
-	}
-	if got := idx.Extract("织忆", 0); got != nil {
-		t.Fatalf("maxEntities=0 应返回 nil, got %v", got)
-	}
-}
-
-func TestExtractCachesVocabularyAndBacksOffOnFailure(t *testing.T) {
-	load, calls := fakeVocab(map[string]float64{"织忆": 3.0e-06})
-	idx := NewEntityIndex(load)
-	now := time.Unix(1700000000, 0)
-	idx.now = func() time.Time { return now }
-
-	idx.Extract("织忆", 1)
-	idx.Extract("织忆", 1)
-	if *calls != 1 {
-		t.Fatalf("TTL 内应只加载一次，calls=%d", *calls)
-	}
-	now = now.Add(11 * time.Minute)
-	idx.Extract("织忆", 1)
-	if *calls != 2 {
-		t.Fatalf("TTL 过期应重新加载，calls=%d", *calls)
-	}
-
-	// 加载失败（空词表）→ 退避期内不重复打 DB，且不 panic
-	failCalls := 0
-	bad := NewEntityIndex(func() map[string]float64 { failCalls++; return nil })
-	bad.now = func() time.Time { return now }
-	if got := bad.Extract("织忆", 1); got != nil {
-		t.Fatalf("空词表应返回 nil, got %v", got)
-	}
-	bad.Extract("织忆", 1)
-	if failCalls != 1 {
-		t.Fatalf("退避期内应只尝试一次，failCalls=%d", failCalls)
-	}
-	now = now.Add(2 * time.Minute)
-	bad.Extract("织忆", 1)
-	if failCalls != 2 {
-		t.Fatalf("退避期过后应重试，failCalls=%d", failCalls)
-	}
-}
-
-func TestExtractDegreeFilterDropsNoiseNode(t *testing.T) {
-	load, _ := fakeVocab(map[string]float64{
-		"天气":  3.0e-06,
-		"一句话": 1.6e-06,
-	})
-	idx := NewEntityIndex(load)
-	idx.Degree = func(name string) int {
-		if name == "一句话" {
-			return 2 // 自动切词噪声节点（实测 graph.db：一句话 deg=2）
-		}
-		return 50
-	}
-	got := idx.Extract("完全不相干的一句话天气不错", 3)
-	if !reflect.DeepEqual(got, []string{"天气"}) {
-		t.Fatalf("got %v want [天气]", got)
-	}
-
-	// 度数过滤把候选清空 → 返回 nil（宁可不给，也别给噪声笔记）
-	idx2 := NewEntityIndex(load)
-	idx2.Degree = func(string) int { return 0 }
-	if got := idx2.Extract("完全不相干的一句话天气不错", 3); got != nil {
-		t.Fatalf("got %v want nil", got)
-	}
-}
-
-func TestNilEntityIndexIsSafe(t *testing.T) {
-	var idx *EntityIndex
-	idx.Warm(0)
-	if got := idx.Extract("织忆", 3); got != nil {
-		t.Fatalf("expected nil, got %v", got)
-	}
-	noLoad := NewEntityIndex(nil)
-	if got := noLoad.Extract("织忆", 3); got != nil {
-		t.Fatalf("expected nil, got %v", got)
-	}
-}

go/internal/api/routes/entity_resolve.go

@@ -1,120 +0,0 @@
-// 织忆 MemoryWeave — 实体名字 → 同名全部节点 id 的并集解析
-//
-// 背景（2026-09-27 图谱重名成因报告）：图谱里同一实体可能有两层节点 ——
-//
-//	· 旧 entity 层：id = 名字（namespace=wiki 等，06-16 起写入）
-//	· 新 concept 层：id = "n_" + 名字（namespace=hermes-main 等，09-26 起写入，边多得多）
-//
-// 而 Navigate 按 id 匹配（`WHERE e.source = '<entity>'`），PageRank 词表键也是 id
-// ⇒ 按名字导航只会走旧层，新层的连接形同隐形（织忆：旧层 6 出边 vs 新层 1674 出边）。
-//
-// 本文件提供并集解析：给定名字，返回**全部**同名节点 id，让调用方对并集展开，
-// 从而两层数据都能进入笔记匹配。
-package routes
-
-import (
-	"fmt"
-	"strings"
-)
-
-// NodeSearcher 只要实现 SearchNodes 即可（governance.GraphStore 满足）。
-// 收窄成小接口是为了单测里能塞假实现，不必实现整个图谱接口。
-type NodeSearcher interface {
-	SearchNodes(label string, namespace string) []map[string]interface{}
-}
-
-// ExactNodeFinder 精确同名解析（governance.SQLiteGraphStore 实现 NodeIDsByName）。
-// 有它就用它 —— SearchNodes 的 LIKE+LIMIT 语义会把精确同名的节点挤出结果。
-type ExactNodeFinder interface {
-	NodeIDsByName(name string) []string
-}
-
-// ResolveEntityIDs 返回与 name 对应的全部节点 id（同名两层都返回）。
-//
-// 语义：
-//   - 优先精确匹配：节点的 name 或 id 与 name 相等（忽略大小写）才算命中，
-//     避免 SearchNodes 的 LIKE 子串语义把「织忆」带出「织忆召回」这类噪声节点。
-//   - 若 gs 实现了 ExactNodeFinder 则走精确 SQL（首选，见 NodeIDsByName 注释）。
-//   - 名字本身始终作为回退候选放在结果里（图谱里查不到、但词表命中的名字仍可按 id 直查）。
-//   - 结果去重，稳定有序：先旧层（id=名字）后新层（id=n_名字），最后是名字回退。
-func ResolveEntityIDs(gs NodeSearcher, name string) []string {
-	name = strings.TrimSpace(name)
-	if name == "" {
-		return nil
-	}
-	ids := make([]string, 0, 2)
-	seen := make(map[string]bool, 4)
-	add := func(id string) {
-		if id == "" || seen[id] {
-			return
-		}
-		seen[id] = true
-		ids = append(ids, id)
-	}
-	if ex, ok := gs.(ExactNodeFinder); ok {
-		for _, id := range ex.NodeIDsByName(name) {
-			add(id)
-		}
-	} else if gs != nil {
-		for _, node := range gs.SearchNodes(name, "") {
-			nid, _ := node["id"].(string)
-			nname, _ := node["name"].(string)
-			if nid == "" {
-				continue
-			}
-			if strings.EqualFold(nname, name) || strings.EqualFold(nid, name) {
-				add(nid)
-			}
-		}
-	}
-	add(name) // 回退：按 id 直查（id == 名字）
-	return ids
-}
-
-// MergePaths 把并集展开得到的路径合并进 dst，按 source|relation|target 去重。
-// 返回合并后的切片（可能原地扩容）；limit > 0 时最多保留 limit 条。
-func MergePaths(dst []map[string]interface{}, src []map[string]interface{}, seen map[string]bool, limit int) []map[string]interface{} {
-	if seen == nil {
-		seen = make(map[string]bool, len(dst)+len(src))
-	}
-	for _, p := range dst {
-		seen[pathKey(p)] = true
-	}
-	for _, p := range src {
-		if limit > 0 && len(dst) >= limit {
-			break
-		}
-		k := pathKey(p)
-		if k == "" || seen[k] {
-			continue
-		}
-		seen[k] = true
-		dst = append(dst, p)
-	}
-	return dst
-}
-
-// PathEnds 取出路径的 (source, target, relation)。
-// 兼容两套键名：governance.Navigate 返回的是 from/to，而其它构造处用 source/target——
-// 只读一套会静默丢路径（2026-09-27 实测：并集路径、以及「图谱邻居进笔记匹配」整条链路
-// 都因为读错键名而失效，全程无报错）。
-func PathEnds(p map[string]interface{}) (string, string, string) {
-	s, _ := p["source"].(string)
-	if s == "" {
-		s, _ = p["from"].(string)
-	}
-	t, _ := p["target"].(string)
-	if t == "" {
-		t, _ = p["to"].(string)
-	}
-	r, _ := p["relation"].(string)
-	return s, t, r
-}
-
-func pathKey(p map[string]interface{}) string {
-	s, t, r := PathEnds(p)
-	if s == "" && t == "" {
-		return ""
-	}
-	return fmt.Sprintf("%s|%s|%s", s, r, t)
-}

go/internal/api/routes/entity_resolve_test.go

@@ -1,170 +0,0 @@
-package routes
-
-import (
-	"strings"
-	"testing"
-)
-
-// fakeSearcher 模拟 SearchNodes 的 LIKE 语义返回，用于验证精确匹配过滤。
-type fakeSearcher struct {
-	nodes []map[string]interface{}
-	calls int
-}
-
-func (f *fakeSearcher) SearchNodes(label, namespace string) []map[string]interface{} {
-	f.calls++
-	out := []map[string]interface{}{}
-	for _, n := range f.nodes {
-		nm, _ := n["name"].(string)
-		id, _ := n["id"].(string)
-		if strings.Contains(nm, label) || strings.Contains(id, label) {
-			out = append(out, n)
-		}
-	}
-	return out
-}
-
-// 同名两层：旧 entity（id=名字）+ 新 concept（id=n_名字）→ 都应返回，且顺序稳定。
-func TestResolveEntityIDs_TwoLayers(t *testing.T) {
-	gs := &fakeSearcher{nodes: []map[string]interface{}{
-		{"id": "织忆", "name": "织忆", "type": "entity"},
-		{"id": "n_织忆", "name": "织忆", "type": "concept"},
-	}}
-	ids := ResolveEntityIDs(gs, "织忆")
-	if len(ids) != 2 {
-		t.Fatalf("want 2 ids (两层), got %v", ids)
-	}
-	if ids[0] != "织忆" || ids[1] != "n_织忆" {
-		t.Fatalf("unexpected order: %v", ids)
-	}
-}
-
-// LIKE 子串噪声必须被挡掉：查「织忆」不应带出「织忆召回」。
-func TestResolveEntityIDs_RejectsSubstringNoise(t *testing.T) {
-	gs := &fakeSearcher{nodes: []map[string]interface{}{
-		{"id": "织忆", "name": "织忆"},
-		{"id": "织忆召回机制", "name": "织忆召回机制"},
-	}}
-	ids := ResolveEntityIDs(gs, "织忆")
-	for _, id := range ids {
-		if id == "织忆召回机制" {
-			t.Fatalf("子串噪声未被过滤: %v", ids)
-		}
-	}
-	if len(ids) != 1 {
-		t.Fatalf("want 1 (仅精确), got %v", ids)
-	}
-}
-
-// 图谱查不到时回退为名字本身（按 id 直查仍可用）。
-func TestResolveEntityIDs_FallbackToName(t *testing.T) {
-	gs := &fakeSearcher{}
-	ids := ResolveEntityIDs(gs, "不存在的实体")
-	if len(ids) != 1 || ids[0] != "不存在的实体" {
-		t.Fatalf("want fallback to name, got %v", ids)
-	}
-}
-
-// nil store / 空名字不外抛。
-func TestResolveEntityIDs_NilAndEmpty(t *testing.T) {
-	if got := ResolveEntityIDs(nil, "织忆"); len(got) != 1 || got[0] != "织忆" {
-		t.Fatalf("nil store 应回退名字: %v", got)
-	}
-	if got := ResolveEntityIDs(nil, "   "); got != nil {
-		t.Fatalf("空名字应返回 nil, got %v", got)
-	}
-}
-
-// 去重：SearchNodes 同时按 name 与 id 命中同一节点时只返回一次。
-func TestResolveEntityIDs_Dedup(t *testing.T) {
-	gs := &fakeSearcher{nodes: []map[string]interface{}{
-		{"id": "n_织忆", "name": "织忆"},
-		{"id": "n_织忆", "name": "n_织忆"},
-	}}
-	ids := ResolveEntityIDs(gs, "织忆")
-	// n_织忆 命中（name 相等）；名字回退也加入 ⇒ 共 2 条且不重复
-	if len(ids) != 2 || ids[0] != "n_织忆" || ids[1] != "织忆" {
-		t.Fatalf("dedup 结果异常: %v", ids)
-	}
-}
-
-// fakeExact 同时实现 NodeSearcher 与 ExactNodeFinder：验证优先走精确 SQL。
-// 模拟真实场景：SearchNodes（LIKE）被 834 条子串命中淹没、精确改名拿不到 ⇒ 必须用精确路径。
-type fakeExact struct {
-	exactIDs []string
-	likeRows []map[string]interface{}
-}
-
-func (f *fakeExact) SearchNodes(label, namespace string) []map[string]interface{} { return f.likeRows }
-func (f *fakeExact) NodeIDsByName(name string) []string                           { return f.exactIDs }
-
-func TestResolveEntityIDs_PrefersExactFinder(t *testing.T) {
-	gs := &fakeExact{
-		exactIDs: []string{"织忆", "n_织忆"},
-		likeRows: []map[string]interface{}{ // LIKE 噪声：精确同名的 n_织忆 不在其中
-			{"id": "n_织忆召回机制", "name": "织忆召回机制"},
-			{"id": "n_织忆架构", "name": "织忆架构"},
-		},
-	}
-	ids := ResolveEntityIDs(gs, "织忆")
-	want := []string{"织忆", "n_织忆"}
-	if len(ids) != len(want) || ids[0] != want[0] || ids[1] != want[1] {
-		t.Fatalf("want %v, got %v", want, ids)
-	}
-}
-
-// MergePaths：按 source|relation|target 去重，并尊重上限。
-func TestMergePaths_TolerantToFromToKeys(t *testing.T) {
-	// governance.Navigate 返回 from/to；MergePaths 必须认，否则路径被静默丢弃
-	nav := []map[string]interface{}{
-		{"from": "织忆", "to": "Hermes", "relation": "USES"},
-		{"from": "织忆", "to": "LanceDB", "relation": "DEPENDS_ON"},
-	}
-	out := MergePaths([]map[string]interface{}{}, nav, nil, 0)
-	if len(out) != 2 {
-		t.Fatalf("Navigate 风格 from/to 路径被丢弃：want 2, got %d", len(out))
-	}
-	// 去重：同一 from|relation|to 再来一次不重复
-	out = MergePaths(out, nav, nil, 0)
-	if len(out) != 2 {
-		t.Fatalf("去重失败：want 2, got %d", len(out))
-	}
-	// limit 生效
-	out = MergePaths([]map[string]interface{}{}, nav, nil, 1)
-	if len(out) != 1 {
-		t.Fatalf("limit 未生效：want 1, got %d", len(out))
-	}
-}
-
-func TestPathEnds_BothKeySets(t *testing.T) {
-	if s, tt, r := PathEnds(map[string]interface{}{"from": "a", "to": "b", "relation": "R"}); s != "a" || tt != "b" || r != "R" {
-		t.Fatalf("from/to 未识别: %s %s %s", s, tt, r)
-	}
-	if s, tt, _ := PathEnds(map[string]interface{}{"source": "a", "target": "b"}); s != "a" || tt != "b" {
-		t.Fatalf("source/target 未识别: %s %s", s, tt)
-	}
-}
-
-func TestMergePaths_DedupAndLimit(t *testing.T) {
-	p := func(s, r, tg string) map[string]interface{} {
-		return map[string]interface{}{"source": s, "relation": r, "target": tg}
-	}
-	dst := []map[string]interface{}{p("a", "is", "b")}
-	seen := map[string]bool{}
-	dst = MergePaths(dst, []map[string]interface{}{
-		p("a", "is", "b"), // 重复
-		p("n_a", "is", "c"),
-		p("n_a", "is", "d"),
-	}, seen, 2)
-	if len(dst) != 2 {
-		t.Fatalf("want limit 2, got %d: %v", len(dst), dst)
-	}
-	if dst[1]["target"] != "c" {
-		t.Fatalf("第二条应为新路径 c, got %v", dst[1])
-	}
-	// 再次合并应识别已有 key（含 dst 内建索引）
-	dst = MergePaths(dst, []map[string]interface{}{p("n_a", "is", "c")}, seen, 0)
-	if len(dst) != 2 {
-		t.Fatalf("重复路径未被去重: %v", dst)
-	}
-}

go/internal/api/routes/eval.go

@@ -4,133 +4,27 @@ package routes
 import (
 	"encoding/json"
 	"net/http"
-	"os"
-	"strings"
 	"sync"
 	"time"
 
 	"github.com/xiaoxue/memoryweave/internal/storage"
 )
 
-// ─── 金标集定义 ──────────────────────────────────────────────
-
-// GoldenSetItem 单条金标：query + 具体 expected_ids + 关键词相关性判据
-type GoldenSetItem struct {
-	Query               string   `json:"query"`
-	ExpectedIDs         []string `json:"expected_ids"`
-	MustIncludeKeywords []string `json:"must_include_keywords"`
-	Category            string   `json:"category,omitempty"`
-	Difficulty          string   `json:"difficulty,omitempty"`
-	IDBaseline          string   `json:"id_baseline,omitempty"`
-}
-
-// GoldenSet 金标集
-type GoldenSet struct {
-	Description string          `json:"description"`
-	Items       []GoldenSetItem `json:"items"`
-}
-
-// LoadGoldenSet 从 testdata/ 加载金标集，支持相对路径（生产用）和绝对路径（测试用）
-func LoadGoldenSet(path string) (*GoldenSet, error) {
-	if path == "" {
-		// 编译后无法直接拿到源码路径，回退到 CWD 的 testdata/
-		path = "testdata/golden-set.json"
-	}
-	data, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	var gs GoldenSet
-	if err := json.Unmarshal(data, &gs); err != nil {
-		return nil, err
-	}
-	// 空断言自守：禁止裸前缀/空串混入（避免恒真）
-	for _, item := range gs.Items {
-		if err := validateExpectedIDs(item.Query, item.ExpectedIDs); err != nil {
-			return nil, err
-		}
-	}
-	return &gs, nil
-}
-
-// validateExpectedIDs 空断言自守：裸前缀 "mem_"、空串、None → 直接报错，不许静默 PASS
-func validateExpectedIDs(query string, expectedIDs []string) error {
-	if len(expectedIDs) == 0 {
-		return nil // 允许空（bootstrap 时还没基线）
-	}
-	for _, id := range expectedIDs {
-		trimmed := strings.TrimSpace(id)
-		// 裸前缀 "mem_"（不含具体 ID 数字）
-		if trimmed == "mem_" || trimmed == "mem" {
-			return &VacuousAssertionError{
-				Query:  query,
-				BadID:  id,
-				Reason: "裸前缀 mem_ 是恒真断言——所有记忆 ID 都以 mem_ 开头",
-			}
-		}
-		// 空串
-		if trimmed == "" {
-			return &VacuousAssertionError{
-				Query:  query,
-				BadID:  id,
-				Reason: "空串期望值（无意义断言）",
-			}
-		}
-		// None（JSON null 解码成空字符串已处理，但检查 "None" 字符串）
-		if strings.EqualFold(trimmed, "none") {
-			return &VacuousAssertionError{
-				Query:  query,
-				BadID:  id,
-				Reason: "None 期望值（无意义断言）",
-			}
-		}
-	}
-	return nil
-}
-
-// VacuousAssertionError 空断言错误
-type VacuousAssertionError struct {
-	Query  string
-	BadID  string
-	Reason string
-}
-
-func (e *VacuousAssertionError) Error() string {
-	return "FATAL 空断言被检出（恒真）: query=" + e.Query + " 期望=" + e.BadID + " — " + e.Reason
-}
-
-// checkKeywordRelevance 关键词相关性判据：返回内容必须包含至少一个关键词。
-// 统一口径（t_a70b07e1）：本函数单条内容判定的输入 N（取 recall 返回的前 N 条）由调用方决定——
-// eval 端 TestEvalGolden_Live 取前 N=5（见 eval_test.go 口径注释），与 golden-check.py 一致。
-func checkKeywordRelevance(content string, keywords []string) bool {
-	if len(keywords) == 0 {
-		// 无关键词判据 → 视为不通过（禁止退化为恒真）
-		return false
-	}
-	lower := strings.ToLower(content)
-	for _, kw := range keywords {
-		if strings.Contains(lower, strings.ToLower(kw)) {
-			return true
-		}
-	}
-	return false
-}
-
 type EvalAPI struct {
 	Pipeline *storage.RecallPipeline
 	LanceDB  storage.LanceDB
 }
 
 type EvalRun struct {
-	ID           string  `json:"id"`
-	Model        string  `json:"model"`
-	RecallAt5    float64 `json:"recall_at_5"`
+	ID        string    `json:"id"`
+	Model     string    `json:"model"`
+	RecallAt5 float64   `json:"recall_at_5"`
 	PrecisionAt5 float64 `json:"precision_at_5"`
-	MRR          float64 `json:"mean_reciprocal_rank"`
-	NDCG         float64 `json:"ndcg"`
+	MRR       float64   `json:"mean_reciprocal_rank"`
+	NDCG      float64   `json:"ndcg"`
 
 	// 按标签分组
-	RecallByTag    map[string]float64 `json:"recall_at_5_by_tag,omitempty"`
+	RecallByTag   map[string]float64 `json:"recall_at_5_by_tag,omitempty"`
 	PrecisionByTag map[string]float64 `json:"precision_at_5_by_tag,omitempty"`
 
 	// 按 Agent 分组
@@ -147,27 +41,17 @@ type EvalRun struct {
 }
 
 type EvalQueryDetail struct {
-	Query               string   `json:"query"`
-	ExpectedIDs         []string `json:"expected_ids"`
-	MustIncludeKeywords []string `json:"must_include_keywords,omitempty"`
-	Hits                []string `json:"hits"`
-	Misses              []string `json:"misses"`
-	RecallAt5           float64  `json:"recall_at_5"`
-	PrecisionAt5        float64  `json:"precision_at_5"`
-	KeywordOK           bool     `json:"keyword_ok,omitempty"`
-}
-
-// GoldenRunResult 金标 run 的扩展结果（含关键词判据）
-type GoldenRunResult struct {
-	EvalRun
-	KeywordPass  int `json:"keyword_pass"`
-	KeywordFail  int `json:"keyword_fail"`
-	KeywordTotal int `json:"keyword_total"`
+	Query       string   `json:"query"`
+	ExpectedIDs []string `json:"expected_ids"`
+	Hits        []string `json:"hits"`
+	Misses      []string `json:"misses"`
+	RecallAt5   float64  `json:"recall_at_5"`
+	PrecisionAt5 float64 `json:"precision_at_5"`
 }
 
 type ConsolidationHits struct {
-	TotalDistilledUsed     int     `json:"total_distilled_used"`
-	HitsAfterConsolidation int     `json:"hits_after_consolidation"`
+	TotalDistilledUsed int     `json:"total_distilled_used"`
+	HitsAfterConsolidation int  `json:"hits_after_consolidation"`
 	ConsolidationBenefit   float64 `json:"consolidation_benefit"`
 }
 
@@ -189,8 +73,7 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
 			Query       string   `json:"query"`
 			ExpectedIDs []string `json:"expected_ids"`
 		} `json:"queries"`
-		Model     string `json:"model"`
-		Namespace string `json:"namespace"` // 支持指定 namespace
+		Model string `json:"model"`
 	}
 
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
@@ -202,20 +85,6 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// 空断言自守：裸前缀 mem_ / 空串 / None → 直接报错，不许静默 PASS
-	for _, q := range req.Queries {
-		if err := validateExpectedIDs(q.Query, q.ExpectedIDs); err != nil {
-			respondError(w, 400, err.Error())
-			return
-		}
-	}
-
-	// 默认 namespace 为 shared，支持传入 hermes 等
-	ns := req.Namespace
-	if ns == "" {
-		ns = "shared"
-	}
-
 	var totalPrecision, totalRecall, totalMRR, totalNDCG float64
 	totalQueries := 0
 
@@ -226,7 +95,7 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
 	var queryDetails []EvalQueryDetail
 
 	for _, q := range req.Queries {
-		results, err := ea.Pipeline.Recall(q.Query, ns, 5, 0.5)
+		results, err := ea.Pipeline.Recall(q.Query, "shared", 5, 0.5)
 		if err != nil {
 			continue
 		}
@@ -250,15 +119,11 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
 		}
 
 		pAt5 := 0.0
-		if len(results) > 0 {
-			pAt5 = float64(hits) / float64(len(results))
-		}
+		if len(results) > 0 { pAt5 = float64(hits) / float64(len(results)) }
 		totalPrecision += pAt5
 
 		rAt5 := 0.0
-		if len(q.ExpectedIDs) > 0 {
-			rAt5 = float64(hits) / float64(len(q.ExpectedIDs))
-		}
+		if len(q.ExpectedIDs) > 0 { rAt5 = float64(hits) / float64(len(q.ExpectedIDs)) }
 		totalRecall += rAt5
 
 		// MRR
@@ -273,17 +138,11 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
 		dcg, idcg := 0.0, 0.0
 		for i, res := range results {
 			rel := 0.0
-			if expectedSet[res.ID] {
-				rel = 1.0
-			}
+			if expectedSet[res.ID] { rel = 1.0 }
 			dcg += rel / log2(float64(i+2))
-			if i < len(q.ExpectedIDs) {
-				idcg += 1.0 / log2(float64(i+2))
-			}
-		}
-		if idcg > 0 {
-			totalNDCG += dcg / idcg
+			if i < len(q.ExpectedIDs) { idcg += 1.0 / log2(float64(i+2)) }
 		}
+		if idcg > 0 { totalNDCG += dcg / idcg }
 
 		// 分组统计
 		// (category 从 query 推断)
@@ -318,18 +177,18 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
 	recallByAgent := avgByGroup(recallByAgentMap)
 
 	run := &EvalRun{
-		ID:             time.Now().Format("20060102-150405"),
-		Model:          req.Model,
-		RecallAt5:      totalRecall / float64(totalQueries),
-		PrecisionAt5:   totalPrecision / float64(totalQueries),
-		MRR:            totalMRR / float64(totalQueries),
-		NDCG:           totalNDCG / float64(totalQueries),
-		RecallByTag:    recallByTag,
+		ID:            time.Now().Format("20060102-150405"),
+		Model:         req.Model,
+		RecallAt5:     totalRecall / float64(totalQueries),
+		PrecisionAt5:  totalPrecision / float64(totalQueries),
+		MRR:           totalMRR / float64(totalQueries),
+		NDCG:          totalNDCG / float64(totalQueries),
+		RecallByTag:   recallByTag,
 		PrecisionByTag: precisionByTag,
-		RecallByAgent:  recallByAgent,
-		QueryDetails:   queryDetails,
-		Queries:        totalQueries,
-		RanAt:          time.Now(),
+		RecallByAgent: recallByAgent,
+		QueryDetails:  queryDetails,
+		Queries:       totalQueries,
+		RanAt:         time.Now(),
 	}
 
 	evals.mu.Lock()
@@ -339,171 +198,6 @@ func (ea *EvalAPI) Run(w http.ResponseWriter, r *http.Request) {
 	respond(w, 200, run)
 }
 
-// POST /api/v1/eval/golden — 使用金标集跑评估（含关键词相关性判据）
-// 加载 testdata/golden-set.json，对每条执行 recall + 关键词检查
-// 返回 GoldenRunResult（含 keyword_pass/fail/total）
-func (ea *EvalAPI) RunGolden(w http.ResponseWriter, r *http.Request) {
-	var req struct {
-		Namespace  string `json:"namespace"`
-		GoldenPath string `json:"golden_path"` // 可选，默认 testdata/golden-set.json
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		respondError(w, 400, "invalid body")
-		return
-	}
-	ns := req.Namespace
-	if ns == "" {
-		ns = "shared"
-	}
-	gs, err := LoadGoldenSet(req.GoldenPath)
-	if err != nil {
-		respondError(w, 500, "failed to load golden set: "+err.Error())
-		return
-	}
-
-	var totalPrecision, totalRecall, totalMRR, totalNDCG float64
-	totalQueries := 0
-	keywordPass, keywordFail, keywordTotal := 0, 0, 0
-	var queryDetails []EvalQueryDetail
-	var failures []string
-
-	for _, item := range gs.Items {
-		// 空断言自守
-		if err := validateExpectedIDs(item.Query, item.ExpectedIDs); err != nil {
-			respondError(w, 400, err.Error())
-			return
-		}
-		// 无关键词判据 → 禁止（会退化成恒真）
-		if len(item.MustIncludeKeywords) == 0 {
-			failures = append(failures, item.Query+": 无关键词判据（禁止退化成恒真）")
-			continue
-		}
-
-		results, err := ea.Pipeline.Recall(item.Query, ns, 5, 0.5)
-		if err != nil {
-			failures = append(failures, item.Query+": recall 失败 "+err.Error())
-			keywordFail++
-			keywordTotal++
-			continue
-		}
-
-		// ID 命中检查
-		hits := 0
-		var hitIDs []string
-		var missIDs []string
-		expectedSet := makeSet(item.ExpectedIDs)
-		for i, res := range results {
-			if expectedSet[res.ID] && i < 5 {
-				hits++
-				hitIDs = append(hitIDs, res.ID)
-			}
-		}
-		for _, eid := range item.ExpectedIDs {
-			if !contains(hitIDs, eid) {
-				missIDs = append(missIDs, eid)
-			}
-		}
-
-		// 关键词相关性判据（t_a70b07e1 统一口径）：取 recall 返回的前 N=5 条内容查关键词。
-		// （Pipeline.Recall 传 topK=5；此处扫全部 results 即前 N 条。Python 量具 golden-check.py 同口径。）
-		keywordOK := false
-		for _, res := range results {
-			if checkKeywordRelevance(res.Content, item.MustIncludeKeywords) {
-				keywordOK = true
-				break
-			}
-		}
-
-		pAt5 := 0.0
-		if len(results) > 0 {
-			pAt5 = float64(hits) / float64(len(results))
-		}
-		totalPrecision += pAt5
-
-		rAt5 := 0.0
-		if len(item.ExpectedIDs) > 0 {
-			rAt5 = float64(hits) / float64(len(item.ExpectedIDs))
-		}
-		totalRecall += rAt5
-
-		// MRR
-		for i, res := range results {
-			if expectedSet[res.ID] {
-				totalMRR += 1.0 / float64(i+1)
-				break
-			}
-		}
-
-		// NDCG
-		dcg, idcg := 0.0, 0.0
-		for i, res := range results {
-			rel := 0.0
-			if expectedSet[res.ID] {
-				rel = 1.0
-			}
-			dcg += rel / log2(float64(i+2))
-			if i < len(item.ExpectedIDs) {
-				idcg += 1.0 / log2(float64(i+2))
-			}
-		}
-		if idcg > 0 {
-			totalNDCG += dcg / idcg
-		}
-
-		// 关键词统计
-		keywordTotal++
-		if keywordOK {
-			keywordPass++
-		} else {
-			keywordFail++
-			failures = append(failures, item.Query+": 关键词未命中 "+strings.Join(item.MustIncludeKeywords, ","))
-		}
-
-		queryDetails = append(queryDetails, EvalQueryDetail{
-			Query:               item.Query,
-			ExpectedIDs:         item.ExpectedIDs,
-			MustIncludeKeywords: item.MustIncludeKeywords,
-			Hits:                hitIDs,
-			Misses:              missIDs,
-			RecallAt5:           rAt5,
-			PrecisionAt5:        pAt5,
-			KeywordOK:           keywordOK,
-		})
-
-		totalQueries++
-	}
-
-	if totalQueries == 0 {
-		respondError(w, 500, "all golden queries failed")
-		return
-	}
-
-	run := &EvalRun{
-		ID:           time.Now().Format("20060102-150405"),
-		Model:        "golden-set",
-		RecallAt5:    totalRecall / float64(totalQueries),
-		PrecisionAt5: totalPrecision / float64(totalQueries),
-		MRR:          totalMRR / float64(totalQueries),
-		NDCG:         totalNDCG / float64(totalQueries),
-		QueryDetails: queryDetails,
-		Queries:      totalQueries,
-		RanAt:        time.Now(),
-	}
-
-	evals.mu.Lock()
-	evals.runs = append(evals.runs, run)
-	evals.mu.Unlock()
-
-	result := GoldenRunResult{
-		EvalRun:      *run,
-		KeywordPass:  keywordPass,
-		KeywordFail:  keywordFail,
-		KeywordTotal: keywordTotal,
-	}
-	_ = failures
-	respond(w, 200, result)
-}
-
 // GET /api/v1/eval/history
 func (ea *EvalAPI) History(w http.ResponseWriter, r *http.Request) {
 	evals.mu.RLock()
@@ -531,10 +225,7 @@ func (ea *EvalAPI) History(w http.ResponseWriter, r *http.Request) {
 	})
 }
 
-// POST /api/v1/eval/generate — 生成 4类×3级=12条金标查询
-// 对每个 query 调用 recall 获取 expected_ids
-// 注意：此端点用于 bootstrap 基线——首次跑时没有基线，用 recall top-3 填充。
-// 后续应改用 LoadGoldenSet 加载已校准的金标集（含具体 ID + 关键词判据）。
+// POST /api/v1/eval/generate — 自动生成金标查询集
 func (ea *EvalAPI) Generate(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		Namespace string `json:"namespace"`
@@ -545,70 +236,32 @@ func (ea *EvalAPI) Generate(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	if req.Namespace == "" {
-		req.Namespace = "hermes"
+		req.Namespace = "shared"
 	}
 	if req.Count <= 0 {
-		req.Count = 12
+		req.Count = 10
 	}
 
-	// 固定的 12 条金标查询（4类×3级）
-	// 对每条生成 query → recall 获得真实 expected_ids
-	goldenQueries := []struct {
-		cat        string
-		difficulty string
-		query      string
-	}{
-		// system_fact
-		{"system_fact", "easy", "织忆是什么"},
-		{"system_fact", "medium", "织忆的图谱扩展机制是什么"},
-		{"system_fact", "hard", "织忆如何通过 E1 提取和 MMR 实现多样去重"},
-		// user_pref
-		{"user_pref", "easy", "牧尘的偏好是什么"},
-		{"user_pref", "medium", "牧尘喜欢什么样的工作方式"},
-		{"user_pref", "hard", "如何根据牧尘的偏好调整记忆检索策略"},
-		// proj_context
-		{"proj_context", "easy", "当前项目的技术栈是什么"},
-		{"proj_context", "medium", "织忆项目有哪些核心组件"},
-		{"proj_context", "hard", "织忆和其他记忆系统相比有什么架构优势"},
-		// tool_usage
-		{"tool_usage", "easy", "如何使用 recall 接口"},
-		{"tool_usage", "medium", "织忆有哪些管理工具"},
-		{"tool_usage", "hard", "如何通过 API 扩展织忆功能"},
+	// 获取高质量记忆作为金标基础
+	memories, err := ea.LanceDB.GetTopByQuality("", req.Count)
+	if err != nil {
+		respondError(w, 500, "generate failed: "+err.Error())
+		return
 	}
 
-	var results []map[string]interface{}
-	for _, gq := range goldenQueries {
-		// recall 获取 top-3 结果作为 expected_ids
-		recallResults, _ := ea.Pipeline.Recall(gq.query, req.Namespace, 3, 0.5)
-		var expectedIDs []string
-		for _, r := range recallResults {
-			if r.ID != "" {
-				expectedIDs = append(expectedIDs, r.ID)
-			}
+	var queries []map[string]interface{}
+	for _, mem := range memories {
+		query := mem.Content
+		if len(query) > 50 {
+			query = query[:50]
 		}
-		// 空断言自守：如果 recall 返回 0 条，不得写入空 expected_ids（那是 bootstrap，不是校准）
-		if len(expectedIDs) == 0 {
-			results = append(results, map[string]interface{}{
-				"query":        gq.query,
-				"expected_ids": []string{},
-				"category":     gq.cat,
-				"difficulty":   gq.difficulty,
-				"warning":      "recall 返回 0 条——bootstrap 基线为空，需人工校准",
-			})
-			continue
-		}
-		results = append(results, map[string]interface{}{
-			"query":        gq.query,
-			"expected_ids": expectedIDs,
-			"category":     gq.cat,
-			"difficulty":   gq.difficulty,
+		queries = append(queries, map[string]interface{}{
+			"query":        query,
+			"expected_ids": []string{mem.ID},
 		})
 	}
-
 	respond(w, 200, map[string]interface{}{
-		"queries": results,
-		"count":   len(results),
-		"note":    "4类别×3难度=12条金标查询，通过 recall 自动获取 expected_ids。注意：bootstrap 模式下 expected_ids 来自实时 recall，非校准基线。校准后的金标集见 testdata/golden-set.json（LoadGoldenSet）。",
+		"queries": queries, "count": len(queries),
 	})
 }
 
@@ -623,21 +276,14 @@ func makeSet(ids []string) map[string]bool {
 
 func log2(x float64) float64 {
 	result := 0.0
-	for x > 2 {
-		x /= 2
-		result += 1
-	}
-	if x > 1 {
-		result += (x - 1)
-	}
+	for x > 2 { x /= 2; result += 1 }
+	if x > 1 { result += (x - 1) }
 	return result
 }
 
 func contains(list []string, item string) bool {
 	for _, s := range list {
-		if s == item {
-			return true
-		}
+		if s == item { return true }
 	}
 	return false
 }
@@ -647,9 +293,7 @@ func avgByGroup(m map[string][]float64) map[string]float64 {
 	for k, vals := range m {
 		if len(vals) > 0 {
 			sum := 0.0
-			for _, v := range vals {
-				sum += v
-			}
+			for _, v := range vals { sum += v }
 			result[k] = sum / float64(len(vals))
 		}
 	}
@@ -658,17 +302,15 @@ func avgByGroup(m map[string][]float64) map[string]float64 {
 
 func inferCategory(query, defaultCat string) string {
 	for cat, keywords := range map[string][]string{
-		"system_fact":  {"os", "系统", "gpu", "内存", "ram", "端口", "配置"},
-		"user_pref":    {"偏好", "风格", "喜欢", "牧尘"},
-		"proj_context": {"项目", "路径", "代码", "设计文档"},
-		"tool_usage":   {"工具", "comfyui", "hermes", "opencode"},
+		"system_fact": {"os", "系统", "gpu", "内存", "ram", "端口", "配置"},
+		"user_pref":   {"偏好", "风格", "喜欢", "牧尘"},
+		"proj_context":{"项目", "路径", "代码", "设计文档"},
+		"tool_usage":  {"工具", "comfyui", "hermes", "opencode"},
 	} {
 		for _, kw := range keywords {
 			if len(query) >= len(kw) {
 				for i := 0; i <= len(query)-len(kw); i++ {
-					if query[i:i+len(kw)] == kw {
-						return cat
-					}
+					if query[i:i+len(kw)] == kw { return cat }
 				}
 			}
 		}

go/internal/api/routes/eval_test.go

@@ -1,435 +0,0 @@
-// 织忆 MemoryWeave — 评估系统测试
-// 覆盖：金标加载 / 空断言自守 / 关键词判据 / 反证 / 全量金标跑（需活服务）
-package routes
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-// ─── recall 辅助：liveRecallOnce ─────────────────────────────
-// 一次 recall API 调用同时拿 top-5 的 ids + contents，避免两条 HTTP（限流保护）。
-// 每次调用间加 200ms 间隔，由调用方负责（TestEvalGolden_Live 里 sleep）。
-//
-// 统一判据口径（t_a70b07e1，与 Python 量具 golden-check.py 一致）：
-//
-//	取 recall 返回的前 N=5 条：ID 命中 = expected_ids 任一 ∈ 前 N 条；
-//	关键词命中 = 前 N 条内容任一含 must_include_keywords（大小写不敏感）。
-//	N=5 的来源：recall 请求 top_k=5（liveRecallOnce 固定），与 golden-set.json 说明字段一致。
-type recallResult struct {
-	IDS         []string
-	TopContents []string
-	Error       error
-}
-
-func liveRecallOnce(query string, maxRetries int, retryWait time.Duration) recallResult {
-	payload, _ := json.Marshal(map[string]interface{}{"query": query, "top_k": 5})
-	var lastErr error
-	for attempt := 0; attempt <= maxRetries; attempt++ {
-		if attempt > 0 {
-			time.Sleep(retryWait * time.Duration(attempt))
-		}
-		req, _ := http.NewRequest("POST", "http://127.0.0.1:7821/api/v1/recall", bytes.NewReader(payload))
-		req.Header.Set("Content-Type", "application/json")
-		req.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
-		resp, err := http.DefaultClient.Do(req)
-		if err != nil {
-			lastErr = fmt.Errorf("HTTP 请求失败: %v", err)
-			continue
-		}
-		body, _ := io.ReadAll(resp.Body)
-		resp.Body.Close()
-		if resp.StatusCode == http.StatusUnauthorized {
-			return recallResult{Error: fmt.Errorf("HTTP 401 unauthorized（API key 无效）")}
-		}
-		if resp.StatusCode != http.StatusOK {
-			// 限流（429）或服务错误：读 retry_after_s，退避重试
-			var errResp struct {
-				Error struct {
-					Code           string `json:"code"`
-					Message        string `json:"message"`
-					RetryAfterSecs int    `json:"retry_after_s"`
-				} `json:"error"`
-			}
-			_ = json.Unmarshal(body, &errResp)
-			lastErr = fmt.Errorf("HTTP %d (%s): %s", resp.StatusCode, errResp.Error.Code, errResp.Error.Message)
-			if resp.StatusCode == http.StatusTooManyRequests {
-				wait := time.Duration(errResp.Error.RetryAfterSecs) * time.Second
-				if wait == 0 {
-					wait = 2 * time.Second
-				}
-				time.Sleep(wait)
-				continue
-			}
-			return recallResult{Error: lastErr}
-		}
-		var result struct {
-			Results []struct {
-				ID      string `json:"id"`
-				Content string `json:"content"`
-			} `json:"results"`
-		}
-		if err := json.Unmarshal(body, &result); err != nil {
-			return recallResult{Error: fmt.Errorf("JSON 解析失败: %v | body=%s", err, string(body[:min(100, len(body))]))}
-		}
-		rr := recallResult{}
-		for _, r := range result.Results {
-			rr.IDS = append(rr.IDS, r.ID)
-			rr.TopContents = append(rr.TopContents, r.Content)
-		}
-		return rr
-	}
-	return recallResult{Error: lastErr}
-}
-
-// keywordHitAnywhere 检查前 N=5 条结果的 content 是否含任一关键词（统一口径 t_a70b07e1：N=5，与 golden-check.py 一致）
-func keywordHitAnywhere(topContents []string, keywords []string) bool {
-	if len(keywords) == 0 {
-		return false
-	}
-	for _, content := range topContents {
-		if checkKeywordRelevance(content, keywords) {
-			return true
-		}
-	}
-	return false
-}
-
-// ─── AC① 空断言自守：validateExpectedIDs ────────────────────
-
-func TestValidateExpectedIDs_RejectsBareMemPrefix(t *testing.T) {
-	err := validateExpectedIDs("测试查询", []string{"mem_"})
-	if err == nil {
-		t.Fatal("✗ 裸前缀 mem_ 未报错（恒真断言漏检）")
-	}
-	va, ok := err.(*VacuousAssertionError)
-	if !ok {
-		t.Fatalf("✗ 期望 VacuousAssertionError，实际 %T: %v", err, err)
-	}
-	t.Logf("✓ 裸前缀拦截：%s", va.Error())
-}
-
-func TestValidateExpectedIDs_RejectsEmptyString(t *testing.T) {
-	err := validateExpectedIDs("测试查询", []string{""})
-	if err == nil {
-		t.Fatal("✗ 空串期望值未报错")
-	}
-	t.Logf("✓ 空串拦截：%s", err.Error())
-}
-
-func TestValidateExpectedIDs_RejectsNone(t *testing.T) {
-	for _, bad := range []string{"None", "none", "NONE"} {
-		if err := validateExpectedIDs("测试查询", []string{bad}); err == nil {
-			t.Fatalf("✗ None 变体 %q 未报错", bad)
-		}
-	}
-	t.Log("✓ None 各变体全部拦截")
-}
-
-func TestValidateExpectedIDs_AllowsRealID(t *testing.T) {
-	if err := validateExpectedIDs("测试查询", []string{"mem_1789153726378940805"}); err != nil {
-		t.Fatalf("✗ 真实 ID 被误拦: %v", err)
-	}
-	t.Log("✓ 真实 ID 放行")
-}
-
-func TestValidateExpectedIDs_AllowsEmptySlice(t *testing.T) {
-	if err := validateExpectedIDs("测试查询", []string{}); err != nil {
-		t.Fatalf("✗ 空 slice（bootstrap）被误拦: %v", err)
-	}
-	t.Log("✓ 空 slice 放行（bootstrap）")
-}
-
-// ─── 关键词判据：checkKeywordRelevance ──────────────────────
-
-func TestCheckKeywordRelevance(t *testing.T) {
-	if !checkKeywordRelevance("用户偏好：牧尘喜欢直接动手", []string{"牧尘"}) {
-		t.Fatal("✗ 应命中「牧尘」")
-	}
-	if checkKeywordRelevance("用户偏好：牧尘喜欢直接动手", []string{"技术栈"}) {
-		t.Fatal("✗ 不应命中「技术栈」")
-	}
-	if !checkKeywordRelevance("MemoryWeave recall API 文档", []string{"RECALL"}) {
-		t.Fatal("✗ 大小写不敏感匹配失败")
-	}
-	if checkKeywordRelevance("任意内容", []string{}) {
-		t.Fatal("✗ 空关键词判据退化成恒真")
-	}
-	t.Log("✓ 关键词判据全部正确")
-}
-
-// ─── LoadGoldenSet：加载 + 校验 ────────────────────────────
-
-func TestLoadGoldenSet_ValidFile(t *testing.T) {
-	p := filepath.Join("testdata", "golden-set.json")
-	if _, err := os.Stat(p); err != nil {
-		t.Skipf("testdata 不在 CWD（测试需在 go/internal/api/routes/ 下跑）: %v", err)
-	}
-	gs, err := LoadGoldenSet(p)
-	if err != nil {
-		t.Fatalf("✗ 加载金标集失败: %v", err)
-	}
-	if gs.Description == "" {
-		t.Error("✗ description 缺失")
-	}
-	if len(gs.Items) != 14 {
-		t.Fatalf("✗ 期望 14 条（12 基线 + 2 目标），实际 %d", len(gs.Items))
-	}
-	for i, item := range gs.Items {
-		if item.Query == "" {
-			t.Fatalf("✗ item %d query 为空", i)
-		}
-		if len(item.ExpectedIDs) == 0 {
-			t.Fatalf("✗ item %d expected_ids 为空（金标必须有具体 ID）", i)
-		}
-		for _, id := range item.ExpectedIDs {
-			if id == "mem_" || id == "mem" || id == "" {
-				t.Fatalf("✗ item %d expected_ids 含裸前缀/空串 %q", i, id)
-			}
-		}
-		if len(item.MustIncludeKeywords) == 0 {
-			t.Fatalf("✗ item %d must_include_keywords 为空（禁止无关键词判据条目）", i)
-		}
-	}
-	t.Logf("✓ 金标集加载成功：%d 条，全部含具体 expected_ids + must_include_keywords", len(gs.Items))
-}
-
-func TestLoadGoldenSet_RejectsVacuousIDs(t *testing.T) {
-	dir := t.TempDir()
-	bad := `{
-		"description": "bad",
-		"items": [
-			{"query": "q1", "expected_ids": ["mem_"], "must_include_keywords": ["a"]}
-		]
-	}`
-	p := filepath.Join(dir, "bad.json")
-	os.WriteFile(p, []byte(bad), 0644)
-	if _, err := LoadGoldenSet(p); err == nil {
-		t.Fatal("✗ 含裸前缀 mem_ 的金标集未被拒绝")
-	} else {
-		t.Logf("✓ 含裸前缀的金标集被拒：%v", err)
-	}
-}
-
-// ─── AC① 反证：故意把某条 expected_id 改成错误 ID → 该条必须 FAIL ───
-// 这是本卡核心验收点：证明判据非恒真（改错期望 → 真 FAIL）
-
-func TestEvalGolden_CounterEvidence(t *testing.T) {
-	// 探活 zhiyid（无服务 → 跳过）
-	healthReq, _ := http.NewRequest("GET", "http://127.0.0.1:7821/api/v1/health", nil)
-	healthReq.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
-	resp, err := http.DefaultClient.Do(healthReq)
-	if err != nil || resp == nil {
-		t.Skipf("zhiyid 服务不可达（%v），跳过反证测试", err)
-	}
-	resp.Body.Close()
-
-	// 1. 先跑一次正常（期望 PASS）
-	gs, err := LoadGoldenSet(filepath.Join("testdata", "golden-set.json"))
-	if err != nil {
-		t.Fatalf("加载金标集失败: %v", err)
-	}
-	// 统一口径 t_a70b07e1：反证测试也按 golden-set.json 的 expected_ids 判定（前 N=5 条），
-	// 保证「故意改坏输入 → 量具 FAIL」的证明与量具实际判据一致。
-
-	// 取第一条（"织忆是什么"，expected=mem_1789153726378940805）
-	item0 := gs.Items[0]
-	t.Logf("反证前：item[0] query=%q expected=%v", item0.Query, item0.ExpectedIDs)
-
-	// 反证前跑一次
-	rrBefore := liveRecallOnce(item0.Query, 3, 2*time.Second)
-	if rrBefore.Error != nil {
-		t.Skipf("recall API 不可用（%v），跳过反证", rrBefore.Error)
-	}
-	idHitBefore := containsAny(rrBefore.IDS, item0.ExpectedIDs)
-	kwHitBefore := keywordHitAnywhere(rrBefore.TopContents, item0.MustIncludeKeywords)
-	if idHitBefore && kwHitBefore {
-		t.Logf("反证前 ✓ PASS: top1=%s kw_hit=%v", firstID(rrBefore.IDS), kwHitBefore)
-	} else {
-		t.Logf("反证前（基线本身就有问题，跳过反证验证）: idHit=%v kwHit=%v", idHitBefore, kwHitBefore)
-		t.Skipf("反证前基线不 PASS，无法验证反证")
-	}
-
-	// 2. 故意改成错误 ID
-	badID := "mem_0000000000000000000" // 不存在的 ID
-	gs2 := &GoldenSet{Items: []GoldenSetItem{}}
-	for _, it := range gs.Items {
-		if it.Query == item0.Query {
-			it.ExpectedIDs = []string{badID}
-		}
-		gs2.Items = append(gs2.Items, it)
-	}
-
-	// 空断言自守：badID 是合法格式（mem_+数字），不被拦截 ✓
-	if err := validateExpectedIDs(item0.Query, []string{badID}); err != nil {
-		t.Fatalf("✗ 反证用 ID %q 被空断言自守误拦: %v", badID, err)
-	}
-
-	// 3. 反证跑：用错误 ID 必须 FAIL
-	rrAfter := liveRecallOnce(item0.Query, 3, 2*time.Second)
-	if rrAfter.Error != nil {
-		t.Fatalf("反证时 recall 失败: %v", rrAfter.Error)
-	}
-	idHitAfter := containsAny(rrAfter.IDS, []string{badID})
-	if idHitAfter {
-		t.Errorf("✗ 反证失败：错误 ID %q 竟然命中（判据恒真！）", badID)
-	} else {
-		t.Logf("反证后 ✓ FAIL（如预期）: top1=%s 不含 %s", firstID(rrAfter.IDS), badID)
-	}
-
-	// 4. 恢复（golden-set.json 没改，只是内存里改了 gs2）
-	t.Logf("反证测试完成：正常=%v 错误ID=%v", idHitBefore, !idHitAfter)
-}
-
-// ─── 全量金标跑（需活 zhiyid 服务；无服务时 skip）──────────
-// 判据：14 条中 12 基线 + 2 目标，跑真实 recall，统计 pass/fail/warn/error。
-// 统一判据口径（t_a70b07e1，与 Python 量具 golden-check.py + golden-set.json 说明字段三方一致）：
-//   取 recall 返回的前 N=5 条内容查关键词；ID 命中 = expected 任一 ∈ 前 N 条。
-//   判定：PASS = id 命中且 kw 命中；WARN = kw 命中但 id 漂移（降级）；FAIL = 其余；ERROR = recall 调用失败。
-//   验收 = 同一批金标经两量具记录（CALIBRATED 行），喂给同一分类器（classify.py）复算，分类差异 = 0。
-// 校准后真实基线 = 12/14（2 条目标知识在库但召回 top-5 不稳定 → 允许 FAIL，不许抹平）。
-// 每次调用后 200ms 间隔 + 限流退避，避免打满 zhiyid 令牌桶。
-
-func TestEvalGolden_Live(t *testing.T) {
-	// 探活 zhiyid（无服务 → 跳过，不污染 CI）
-	healthReq, _ := http.NewRequest("GET", "http://127.0.0.1:7821/api/v1/health", nil)
-	healthReq.Header.Set("X-API-Key", "zhiyi-dev-key-2026")
-	resp, err := http.DefaultClient.Do(healthReq)
-	if err != nil || resp == nil {
-		t.Skipf("zhiyid 服务不可达（%v），跳过全量金标实跑", err)
-	}
-	defer resp.Body.Close()
-	body, _ := io.ReadAll(resp.Body)
-	if resp.StatusCode != http.StatusOK {
-		t.Skipf("zhiyid 服务 HTTP %d: %s", resp.StatusCode, string(body[:min(80, len(body))]))
-	}
-
-	gs, err := LoadGoldenSet(filepath.Join("testdata", "golden-set.json"))
-	if err != nil {
-		t.Fatalf("加载金标集失败: %v", err)
-	}
-
-	pass, fail, warn, errorCount := 0, 0, 0, 0
-	for i, item := range gs.Items {
-		// 空断言自守
-		if err := validateExpectedIDs(item.Query, item.ExpectedIDs); err != nil {
-			t.Fatalf("item %d 空断言自守失败: %v", i, err)
-		}
-
-		// 一次 HTTP 调用同时拿 top-5 ids + contents（限流保护）
-		rr := liveRecallOnce(item.Query, 3, 2*time.Second)
-		if rr.Error != nil {
-			errorCount++
-			t.Logf("ERROR[%d] %q: recall 错误 %v", i, item.Query, rr.Error)
-			t.Logf("CALIBRATED[%d] %s", i, fmt.Sprintf(
-				`{"tool":"go","i":%d,"query":%q,"top1":"","ids":null,"kw_hit":false,"id_hit":false,"error":%q}`,
-				i, item.Query, rr.Error.Error()))
-			continue
-		}
-
-		// 判据① ID 命中（前 N=5 条里有 expected_ids 之一）—— 统一口径 t_a70b07e1
-		idHit := containsAny(rr.IDS, item.ExpectedIDs)
-
-		// 判据② 关键词相关性（前 N=5 条结果 content 任一含关键词）—— 统一口径 t_a70b07e1
-		kwHit := keywordHitAnywhere(rr.TopContents, item.MustIncludeKeywords)
-
-		// 结构化记录：供统一口径分类器 classify.py 复算 go/py 分类差异（AC1 验收 = 差异 0）
-		t.Logf("CALIBRATED[%d] %s", i, fmt.Sprintf(
-			`{"tool":"go","i":%d,"query":%q,"top1":%q,"ids":%v,"kw_hit":%v,"id_hit":%v,"error":null}`,
-			i, item.Query, firstID(rr.IDS), rr.IDS, kwHit, idHit))
-
-		if idHit && kwHit {
-			pass++
-			t.Logf("PASS[%d] %q top1=%s", i, item.Query, firstID(rr.IDS))
-		} else {
-			fail++
-			why := []string{}
-			if !idHit {
-				if kwHit {
-					// ID 漂移但内容切题 → 降级为 WARN（不算硬 FAIL）
-					why = append(why, fmt.Sprintf("ID漂移(基线 %v ∉ top-5 %v, 但内容切题)",
-						item.ExpectedIDs, rr.IDS[:min(3, len(rr.IDS))]))
-					warn++
-				} else {
-					why = append(why, fmt.Sprintf("ID未命中(期望 %v, top-5 %v)",
-						item.ExpectedIDs, rr.IDS[:min(3, len(rr.IDS))]))
-				}
-			}
-			if !kwHit {
-				head := ""
-				if len(rr.TopContents) > 0 {
-					head = rr.TopContents[0][:min(40, len(rr.TopContents[0]))]
-				}
-				why = append(why, fmt.Sprintf("关键词未命中(%v) | top1_content: %s",
-					item.MustIncludeKeywords, head))
-			}
-			// ID 漂移但内容切题 → 降级为 WARN，不算硬 FAIL
-			if kwHit && !idHit {
-				fail--
-				t.Logf("WARN[%d] %q %v", i, item.Query, why)
-			} else {
-				t.Logf("FAIL[%d] %q %v | top1: %s", i, item.Query, why, firstID(rr.IDS))
-			}
-		}
-
-		// 条目间隔 200ms（限流保护，避免连续打满令牌桶）
-		time.Sleep(200 * time.Millisecond)
-	}
-
-	// 结尾打印真实数字（不写死任何期望值）
-	total := len(gs.Items)
-	t.Logf("RESULT: total=%d pass=%d fail=%d warn=%d error=%d（真实数字，无硬编码基线）",
-		total, pass, fail, warn, errorCount)
-
-	// 漏跑检查：pass+fail+warn+error 必须 = 总条数
-	if pass+fail+warn+errorCount != total {
-		t.Errorf("✗ 漏跑：pass+fail+warn+error=%d ≠ 总条数 %d", pass+fail+warn+errorCount, total)
-	}
-
-	// 全灭（pass=0）→ 判据可能已失效或金标集 ID 已过期
-	if pass == 0 {
-		t.Errorf("✗ 全灭（pass=0）——关键词判据可能失效或金标集 ID 已过期")
-	}
-
-	// 校准基线（供人工校准，不写死期望值）
-	t.Logf("校准基线：pass=%d/%d（fail=%d warn=%d error=%d）", pass, total, fail, warn, errorCount)
-
-	// error 条目 → 服务问题，不计入 fail 但必须报告
-	if errorCount > 0 {
-		t.Logf("⚠ %d 条 ERROR（recall API 调用失败，非召回质量问题）", errorCount)
-	}
-}
-
-// containsAny 检查 expectedIDs 中是否有任意一个出现在 recalledIDs 中
-func containsAny(recalledIDs []string, expectedIDs []string) bool {
-	set := makeSet(expectedIDs)
-	for _, id := range recalledIDs {
-		if set[id] {
-			return true
-		}
-	}
-	return false
-}
-
-// firstID 取 slice 第一个元素
-func firstID(ids []string) string {
-	if len(ids) == 0 {
-		return "(无)"
-	}
-	return ids[0]
-}
-
-// min 取两个整数较小值
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

go/internal/api/routes/feedback.go

@@ -3,16 +3,14 @@ package routes
 
 import (
 	"encoding/json"
-	"log"
 	"net/http"
 
-	"github.com/xiaoxue/memoryweave/internal/metrics"
 	"github.com/xiaoxue/memoryweave/internal/selfoptimize"
 	"github.com/xiaoxue/memoryweave/internal/storage"
 )
 
 type FeedbackAPI struct {
-	LanceDB storage.LanceDB
+	LanceDB  storage.LanceDB
 }
 
 func NewFeedbackAPI(ldb storage.LanceDB) *FeedbackAPI {
@@ -40,27 +38,7 @@ func (fa *FeedbackAPI) MarkUseful(w http.ResponseWriter, r *http.Request) {
 		[]string{req.MemoryID},
 		"user_feedback", "success", "",
 	)
-	if err := fa.LanceDB.IncrementUseful(req.MemoryID); err != nil {
-		log.Printf("[feedback] IncrementUseful failed %s: %v", req.MemoryID, err)
-	}
-	// GA-P0-4 (t_bb10e8bc)：用户点「有用」= 真实正向 outcome → 追加 hits+ 事件（带时间戳）。
-	// 语义定义见 internal/storage/hit_event.go（hits+ = 被真实使用/认可）。
-	if err := fa.LanceDB.AppendHitEvent(req.MemoryID, "pos", "human_feedback"); err != nil {
-		log.Printf("[feedback] AppendHitEvent(pos) failed %s: %v", req.MemoryID, err)
-	}
-
-	// Phase F: 质量监控 — 每次反馈后检查低质量记忆
-	feedbackCount := selfoptimize.Dash.UsefulCount + selfoptimize.Dash.NotUsefulCount
-	qualityScore := selfoptimize.Dash.QualityScore()
-	if record := selfoptimize.QualityMonitor.Check(req.MemoryID, qualityScore, feedbackCount); record != nil {
-		log.Printf("[quality] low-quality memory flagged: id=%s score=%.2f status=%s",
-			record.MemoryID, record.Score, record.Status)
-		// 同步 DeprecatedPerDay 指标
-		metrics.DeprecatedPerDay.Set(float64(selfoptimize.Dash.DeprecatedToday))
-	}
-	// 同步 Dashboard 指标到 Prometheus
-	metrics.SyncFromDashboard(selfoptimize.Dash.Metrics())
-
+	fa.LanceDB.IncrementUseful(req.MemoryID)
 	respond(w, 200, map[string]string{"status": "ok", "memory_id": req.MemoryID})
 }
 
@@ -85,27 +63,7 @@ func (fa *FeedbackAPI) MarkNotUseful(w http.ResponseWriter, r *http.Request) {
 		[]string{req.MemoryID},
 		"user_feedback", "failure", "",
 	)
-	// GA-P0-1 (t_718d8707)：人工点「没用」→ 写 human_not_useful_count（不再写混写列 not_useful_count）
-	if err := fa.LanceDB.IncrementHumanNotUseful(req.MemoryID); err != nil {
-		log.Printf("[feedback] IncrementHumanNotUseful failed %s: %v", req.MemoryID, err)
-	}
-	// GA-P0-4 (t_bb10e8bc)：用户点「没用」= 真实负向 outcome → 追加 hits− 事件（带时间戳）。
-	// 注意：这只在用户人工点「没用」时追加，dedup 自动降权走 dedup_downweight_count 不追加（见 hit_event.go 排除项）。
-	if err := fa.LanceDB.AppendHitEvent(req.MemoryID, "neg", "human_feedback"); err != nil {
-		log.Printf("[feedback] AppendHitEvent(neg) failed %s: %v", req.MemoryID, err)
-	}
-
-	// Phase F: 质量监控 — negative feedback 触发低质量检测
-	feedbackCount := selfoptimize.Dash.UsefulCount + selfoptimize.Dash.NotUsefulCount
-	qualityScore := selfoptimize.Dash.QualityScore()
-	if record := selfoptimize.QualityMonitor.Check(req.MemoryID, qualityScore, feedbackCount); record != nil {
-		log.Printf("[quality] low-quality memory flagged: id=%s score=%.2f status=%s",
-			record.MemoryID, record.Score, record.Status)
-		metrics.DeprecatedPerDay.Set(float64(selfoptimize.Dash.DeprecatedToday))
-	}
-	// 同步 Dashboard 指标到 Prometheus
-	metrics.SyncFromDashboard(selfoptimize.Dash.Metrics())
-
+	fa.LanceDB.IncrementNotUseful(req.MemoryID)
 	respond(w, 200, map[string]string{"status": "ok", "memory_id": req.MemoryID})
 }
 
@@ -125,18 +83,16 @@ func (fa *FeedbackAPI) Deprecate(w http.ResponseWriter, r *http.Request) {
 	}
 
 	selfoptimize.Dash.RecordDeprecation()
-	if err := fa.LanceDB.SoftDelete(req.MemoryID, req.Reason); err != nil {
-		log.Printf("[softdelete] failed id: %v", err)
-	}
+	fa.LanceDB.SoftDelete(req.MemoryID, req.Reason)
 	respond(w, 200, map[string]string{"status": "deprecated", "memory_id": req.MemoryID})
 }
 
 // POST /api/v1/feedback/correct
 func (fa *FeedbackAPI) Correct(w http.ResponseWriter, r *http.Request) {
 	var req struct {
-		MemoryID   string `json:"memory_id"`
-		NewContent string `json:"new_content"`
-		Source     string `json:"source"`
+		MemoryID      string `json:"memory_id"`
+		NewContent    string `json:"new_content"`
+		Source        string `json:"source"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		respondError(w, 400, "invalid body")

go/internal/api/routes/gap_repair.go

@@ -14,19 +14,19 @@ import (
 
 // GapAutoRepair 缺口自动修复器
 type GapAutoRepair struct {
-	detector *selfoptimize.GapDetector
-	ldb      storage.LanceDB
-	synonyms map[string][]string // 同义词映射
+	detector  *selfoptimize.GapDetector
+	ldb       storage.LanceDB
+	synonyms  map[string][]string // 同义词映射
 }
 
 var GapRepair = &GapAutoRepair{
 	detector: nil, // 由 InitGapRepair 注入
 	synonyms: map[string][]string{
-		"GPU":  {"gpu", "显卡", "graphics"},
-		"OS":   {"os", "操作系统", "系统"},
-		"API":  {"api", "接口", "endpoint"},
-		"SSE":  {"sse", "server-sent events", "事件推送"},
-		"CRDT": {"crdt", "冲突合并", "merge"},
+		"GPU":   {"gpu", "显卡", "graphics"},
+		"OS":    {"os", "操作系统", "系统"},
+		"API":   {"api", "接口", "endpoint"},
+		"SSE":   {"sse", "server-sent events", "事件推送"},
+		"CRDT":  {"crdt", "冲突合并", "merge"},
 	},
 }
 

go/internal/api/routes/graph.go

@@ -60,25 +60,21 @@ func (ga *GraphAPI) Query(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// 默认跨 namespace 搜索（空 = 匹配所有，§2.5.6）
-	results := ga.Graph.Query(NormalizeEntity(req.Entity), req.Relation, req.Namespace)
+	results := ga.Graph.Query(normalizeEntity(req.Entity), req.Relation, req.Namespace)
 	respond(w, 200, map[string]interface{}{"results": results, "count": len(results)})
 }
 
 // POST /api/v1/graph/navigate
-// 支持三种模式：
-//  1. 单实体 BFS: {"entity": "...", "max_hops": 2}
-//  2. 双向 BFS: {"source": "...", "target": "...", "max_hops": 3}
-//  3. 关系过滤 BFS: {"entity": "...", "max_hops": 2, "relation_filter": ["related_to", "uses"]}（E1.5）
-//
-// 返回新增 grouped_by_relation 字段，按关系类型分组，便于阅读
+// 支持两种模式：
+//   1. 单实体 BFS: {"entity": "...", "max_hops": 2}
+//   2. 双向 BFS: {"source": "...", "target": "...", "max_hops": 3}（设计文档 §2.5.4）
 func (ga *GraphAPI) Navigate(w http.ResponseWriter, r *http.Request) {
 	var req struct {
-		Entity         string   `json:"entity"`
-		Source         string   `json:"source"`
-		Target         string   `json:"target"`
-		MaxHops        int      `json:"max_hops"`
-		Namespace      string   `json:"namespace"`
-		RelationFilter []string `json:"relation_filter"` // E1.5: 关系类型白名单
+		Entity    string `json:"entity"`
+		Source    string `json:"source"`
+		Target    string `json:"target"`
+		MaxHops   int    `json:"max_hops"`
+		Namespace string `json:"namespace"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		respondError(w, 400, "invalid body")
@@ -88,33 +84,18 @@ func (ga *GraphAPI) Navigate(w http.ResponseWriter, r *http.Request) {
 		req.MaxHops = 2
 	}
 
-	// 响应体积上限：与 /graph/notes 同因同治（2026-09-27 小怡）。
-	// 实测 navigate("牧尘", 2) 服务端吐 34,465 条 ≈3.4MB，再加 grouped_by_relation 同量级复制
-	// ⇒ 单次响应 ~7MB。全仓调用点核对（3 处）都只读样本，paths 全量无人消费：
-	//   - hermes 插件 plugins/zhiyi/__init__.py:911 → for p in paths[:50]
-	//   - web-ui/index.html → 只读 d.count（不渲染 paths）
-	//   - openclaw 客户端 → 已退役
-	// ⇒ paths 截断为可观测样本；count 仍报真实总数（调用方用它显示 "Found N paths"）。
-	const maxNavigatePaths = 200
-
 	// 模式 2: 双向 BFS（source + target）
 	if req.Source != "" && req.Target != "" {
-		source := NormalizeEntity(req.Source)
-		target := NormalizeEntity(req.Target)
-		paths, err := ga.Graph.NavigateBiDir(source, target, req.MaxHops, req.Namespace, req.RelationFilter)
+		source := normalizeEntity(req.Source)
+		target := normalizeEntity(req.Target)
+		paths, err := ga.Graph.NavigateBiDir(source, target, req.MaxHops, req.Namespace)
 		if err != nil {
 			respondError(w, 500, "navigate failed: "+err.Error())
 			return
 		}
-		totalPaths := len(paths)
-		if totalPaths > maxNavigatePaths {
-			paths = paths[:maxNavigatePaths]
-		}
 		respond(w, 200, map[string]interface{}{
 			"paths": paths, "source": req.Source, "target": req.Target,
-			"bidirectional": true, "count": totalPaths,
-			"returned": len(paths), "truncated": totalPaths > len(paths),
-			"relation_filter": req.RelationFilter,
+			"bidirectional": true, "count": len(paths),
 		})
 		return
 	}
@@ -124,69 +105,17 @@ func (ga *GraphAPI) Navigate(w http.ResponseWriter, r *http.Request) {
 		respondError(w, 400, "entity (or source+target) required")
 		return
 	}
-	entity := NormalizeEntity(req.Entity)
-	paths, err := ga.Graph.Navigate(entity, req.MaxHops, req.Namespace, req.RelationFilter)
+	entity := normalizeEntity(req.Entity)
+	paths, err := ga.Graph.Navigate(entity, req.MaxHops, req.Namespace)
 	if err != nil {
 		respondError(w, 500, "navigate failed: "+err.Error())
 		return
 	}
-
-	// paths 截断（见函数开头 maxNavigatePaths 说明）；grouped/suggestions 基于截断后样本构建。
-	totalPaths := len(paths)
-	if totalPaths > maxNavigatePaths {
-		paths = paths[:maxNavigatePaths]
-	}
-
-	// 新增：按 relation 分组，更直观
-	grouped := make(map[string][]map[string]interface{})
-	for _, p := range paths {
-		rel := p["relation"].(string)
-		if rel == "" {
-			rel = "_unknown"
-		}
-		grouped[rel] = append(grouped[rel], map[string]interface{}{
-			"from":   stripPrefix(p["from"].(string)),
-			"to":     stripPrefix(p["to"].(string)),
-			"weight": p["weight"],
-			"hop":    p["hop"],
-		})
-	}
-
-	// 新增：相关实体建议（从 path 提取去重的 to 节点，跳过 ep_ 开头的）
-	suggestions := []string{}
-	seen := make(map[string]bool)
-	for _, p := range paths {
-		to := stripPrefix(p["to"].(string))
-		if !seen[to] && !strings.HasPrefix(p["to"].(string), "ep_") {
-			seen[to] = true
-			suggestions = append(suggestions, to)
-		}
-	}
-	if len(suggestions) > 20 {
-		suggestions = suggestions[:20]
-	}
-
-	respond(w, 200, map[string]interface{}{
-		"paths":               paths,
-		"grouped_by_relation": grouped,
-		"entity":              req.Entity,
-		"normalized_entity":   entity,
-		"count":               totalPaths,
-		"returned":            len(paths),
-		"truncated":           totalPaths > len(paths),
-		"relation_count":      len(grouped),
-		"suggestions":         suggestions,
-		"relation_filter":     req.RelationFilter,
-	})
+	respond(w, 200, map[string]interface{}{"paths": paths, "entity": req.Entity, "count": len(paths)})
 }
 
-// stripPrefix 去掉节点 ID 的 n_ 前缀，用于可读展示
-func stripPrefix(id string) string {
-	return strings.TrimPrefix(id, "n_")
-}
-
-// NormalizeEntity 规整实体名：去特殊字符 + n_前缀，保留中文和 Unicode 字符
-func NormalizeEntity(entity string) string {
+// normalizeEntity 规整实体名：去特殊字符 + n_前缀，保留中文和 Unicode 字符
+func normalizeEntity(entity string) string {
 	if strings.HasPrefix(entity, "n_") {
 		entity = entity[2:]
 	}

go/internal/api/routes/health.go

@@ -4,19 +4,9 @@ package routes
 import (
 	"encoding/json"
 	"net/http"
-
-	"github.com/xiaoxue/memoryweave/internal/consolidate"
 )
 
-// sidecarHealthCheck 探测 Rust sidecar（zhiyi-consolidate）可达性。
-// 声明为变量以便测试注入，默认走真实 IPC 探测。
-var sidecarHealthCheck = consolidate.HealthCheck
-
 // HandleHealth GET /health — 无需认证
-//
-// 深健康检查：不仅报告自身存活，还探测 IPC sidecar 是否可达。
-// 背景（2026-10-08 故障）：sidecar 异常时 /health 仍返回 200 —— "假绿"，
-// 使部署失败被静默数小时，只能靠 pgrep 才发现。深检查把依赖故障暴露为 503。
 func HandleHealth(w http.ResponseWriter, r *http.Request) {
 	if r.Method != http.MethodGet {
 		http.Error(w, `{"error":"method not allowed"}`, http.StatusMethodNotAllowed)
@@ -24,23 +14,10 @@ func HandleHealth(w http.ResponseWriter, r *http.Request) {
 	}
 
 	w.Header().Set("Content-Type", "application/json")
-
-	body := map[string]string{
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(map[string]string{
 		"status":  "ok",
 		"service": "zhiyid",
 		"version": "0.1.0",
-	}
-
-	if err := sidecarHealthCheck(); err != nil {
-		body["status"] = "degraded"
-		body["sidecar"] = "unreachable"
-		body["error"] = err.Error()
-		w.WriteHeader(http.StatusServiceUnavailable)
-		json.NewEncoder(w).Encode(body)
-		return
-	}
-	body["sidecar"] = "ok"
-
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(body)
+	})
 }

go/internal/api/routes/l3.go

@@ -26,17 +26,17 @@ type WorldModel struct {
 
 	Services []ServiceInfo `json:"services"` // ℐ: 服务和端口
 
-	ImplicitRules   []string `json:"implicit_rules"`   // C: 软约束
-	HardConstraints []string `json:"hard_constraints"` // C: 硬约束
-	Capabilities    []string `json:"capabilities"`
+	ImplicitRules []string `json:"implicit_rules"`      // C: 软约束
+	HardConstraints []string `json:"hard_constraints"`   // C: 硬约束
+	Capabilities   []string `json:"capabilities"`
 
 	UpdatedAt string `json:"updated_at"`
 }
 
 type ServiceInfo struct {
-	Name      string   `json:"name"`
-	Port      int      `json:"port"`
-	Status    string   `json:"status"`
+	Name    string   `json:"name"`
+	Port    int      `json:"port"`
+	Status  string   `json:"status"`
 	DependsOn []string `json:"depends_on,omitempty"`
 	Provides  []string `json:"provides,omitempty"`
 }
@@ -111,13 +111,13 @@ func (wm *WorldModel) GetHandler(w http.ResponseWriter, r *http.Request) {
 // POST /api/v1/l3/worldmodel — 更新
 func (wm *WorldModel) UpdateHandler(w http.ResponseWriter, r *http.Request) {
 	var req struct {
-		Environment *struct {
+		Environment   *struct {
 			OS   string `json:"os"`
 			GPU  string `json:"gpu"`
 			VRAM string `json:"vram"`
 			RAM  string `json:"ram"`
 		} `json:"environment"`
-		AddRules        []string `json:"add_rules"`
+		AddRules    []string `json:"add_rules"`
 		AddCapabilities []string `json:"add_capabilities"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {

go/internal/api/routes/obsidian.go

@@ -2,8 +2,6 @@
 package routes
 
 import (
-	"crypto/sha256"
-	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"log"
@@ -13,9 +11,7 @@ import (
 	"strings"
 	"sync"
 	"time"
-	"unicode"
 
-	"github.com/xiaoxue/memoryweave/internal/redact"
 	"github.com/xiaoxue/memoryweave/internal/storage"
 )
 
@@ -56,29 +52,14 @@ func (s *ObsidianSyncer) PushToObsidian(memories []map[string]interface{}, folde
 	}
 
 	count := 0
-	used := make(map[string]int, len(memories))
 	for _, mem := range memories {
 		content := strVal(mem["content"])
-		// 2026-09-10 P0：镜像正文同样脱敏——旧事故里正文与文件名都把
-		// tskey-auth-… 原样落盘（小唯/07-Wiki/织忆/未找到命令.md）。
-		content = redact.RedactSecrets(content)
 		if len(content) < 5 {
 			continue
 		}
 
-		// 2026-09-10 修复：旧实现 content[:30] 按字节切 + sanitizeFilename 把非 ASCII
-		// 全替换成 '_'，中文标题直接变 ____123.md（07-Wiki/织忆 1628 个乱码文件名成因），
-		// 且不同记忆撞名会静默互相覆盖。改为 rune 级截断 + 保留 Unicode + 撞名加短哈希。
-		base := sanitizeFilename(truncateRunes(content, 30))
-		if base == "" {
-			base = "untitled"
-		}
-		if used[base] > 0 {
-			base = base + "-" + shortHash(content)
-		}
-		used[base]++
-		filename := base + ".md"
-		target := filepath.Join(targetDir, filename)
+		filename := sanitizeFilename(content[:minz(len(content), 30)]) + ".md"
+		filepath := filepath.Join(targetDir, filename)
 
 		mdContent := fmt.Sprintf(`---
 id: %s
@@ -99,7 +80,7 @@ sync_time: %s
 			truncate(content, 60),
 			content)
 
-		if err := os.WriteFile(target, []byte(mdContent), 0644); err != nil {
+		if err := os.WriteFile(filepath, []byte(mdContent), 0644); err != nil {
 			log.Printf("[obsidian] 写入失败 %s: %v", filename, err)
 			continue
 		}
@@ -225,61 +206,29 @@ func (s *ObsidianSyncer) StatusHandler(w http.ResponseWriter, r *http.Request) {
 
 // ─── 辅助 ─────────────────────────────────────────────────
 
-// sanitizeFilename 把标题转成文件系统安全的文件名片段，并保留 Unicode（中文）可读性。
-//
-// 2026-09-10 修复：旧实现把所有非 ASCII rune 逐个替换为 '_'，于是中文标题全变成
-// `____123.md`，在 Obsidian 里无法按名浏览（07-Wiki/织忆 1628 个 legacy 文件的成因）。
-// 现在只替换文件系统非法字符（/ \ : * ? " < > | 控制符等），连续的非法字符折叠成一个 '_'。
-// 返回空串表示内容里没有任何可用的安全字符，由调用方兜底。
 func sanitizeFilename(s string) string {
-	// 2026-09-10 P0：入参先脱敏，防任何路径把凭证带进文件名
-	s = redact.RedactSecrets(s)
-	var b strings.Builder
-	prevIllegal := false
-	for _, r := range s {
-		if unicode.IsLetter(r) || unicode.IsDigit(r) ||
-			r == '-' || r == '_' || r == ' ' || r == '.' {
-			prevIllegal = false
-			b.WriteRune(r)
-			continue
+	s = strings.Map(func(r rune) rune {
+		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
+			(r >= '0' && r <= '9') || r == '_' || r == '-' || r == ' ' {
+			return r
 		}
-		// 文件系统非法字符（/ \ : * ? " < > | 控制符等）+ 其它符号 → 折叠成一个 '_'
-		if !prevIllegal {
-			b.WriteRune('_')
-			prevIllegal = true
-		}
-	}
-	return strings.Trim(b.String(), " ._-")
+		return '_'
+	}, s)
+	return strings.TrimSpace(s)
 }
 
-// shortHash 取内容摘要前 8 位十六进制，仅用于同名文件消歧，不做安全用途。
-func shortHash(s string) string {
-	sum := sha256.Sum256([]byte(s))
-	return hex.EncodeToString(sum[:4])
-}
-
-// truncateRunes 按 rune（而非字节）截断，避免把多字节字符切掉一半产生乱码。
-func truncateRunes(s string, maxRunes int) string {
-	if maxRunes <= 0 {
-		return ""
-	}
-	n := 0
-	for i := range s {
-		if n == maxRunes {
-			return s[:i]
-		}
-		n++
-	}
-	return s
-}
-
-// truncate 展示用截断，按 rune 计数（2026-09-10 从字节切改为 rune 切，避免乱码）。
 func truncate(s string, maxLen int) string {
-	t := truncateRunes(s, maxLen)
-	if len(t) == len(s) {
+	if len(s) <= maxLen {
 		return s
 	}
-	return t + "..."
+	return s[:maxLen] + "..."
+}
+
+func minz(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
 }
 
 func floatVal(v interface{}) float64 {

go/internal/api/routes/obsidian_carrier.go

@@ -103,10 +103,8 @@ func formatEntry(content, category string) string {
 
 func strValSafe(v interface{}) string {
 	switch s := v.(type) {
-	case string:
-		return s
-	case fmt.Stringer:
-		return s.String()
+	case string: return s
+	case fmt.Stringer: return s.String()
 	}
 	return ""
 }

go/internal/api/routes/obsidian_test.go

@@ -1,182 +0,0 @@
-// 织忆 MemoryWeave — Obsidian 同步文件名/slug 单元测试
-// 2026-09-10 新增（kanban t_5f9c56ef）：锁死「中文标题不许变下划线」这个回归。
-package routes
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"unicode/utf8"
-)
-
-func TestSanitizeFilename_KeepsChinese(t *testing.T) {
-	cases := []struct {
-		in   string
-		want string
-	}{
-		{"修复了respond重复声明问题", "修复了respond重复声明问题"},
-		{"110GB 磁盘占用排查", "110GB 磁盘占用排查"},
-		{"E5.3 Web UI 单文件React+静态文件中间件", "E5.3 Web UI 单文件React_静态文件中间件"},
-		{"a/b\\c:d*e?f\"g<h>i|j", "a_b_c_d_e_f_g_h_i_j"},
-		{"  前后空格  ", "前后空格"},
-		{"...隐藏点开头...", "隐藏点开头"},
-		{"///", ""},
-		{"", ""},
-		{"测试::连续非法字符::折叠", "测试_连续非法字符_折叠"},
-	}
-	for _, c := range cases {
-		if got := sanitizeFilename(c.in); got != c.want {
-			t.Errorf("sanitizeFilename(%q) = %q, want %q", c.in, got, c.want)
-		}
-	}
-}
-
-// 回归锁：旧实现（2026-09-10 前）会把中文全部换成 '_'，这条用例就是当时的现场。
-func TestSanitizeFilename_RegressionNoUnderscoreSoup(t *testing.T) {
-	got := sanitizeFilename("____112GB_____")
-	if strings.Contains(got, "____") {
-		t.Fatalf("中文标题不该出现连续下划线乱码: %q", got)
-	}
-	old := sanitizeFilename("修复了respond重复声明问题")
-	if strings.Contains(old, "_") {
-		t.Fatalf("中文/字母不该被替换成下划线: %q", old)
-	}
-}
-
-func TestTruncateRunes_NoBrokenUTF8(t *testing.T) {
-	s := "修复了respond重复声明问题，这是很长的中文内容用来测试截断"
-	got := truncateRunes(s, 7)
-	if got != "修复了resp" {
-		t.Fatalf("truncateRunes = %q", got)
-	}
-	if !utf8.ValidString(got) {
-		t.Fatal("截断结果不是合法 UTF-8（多字节字符被切半）")
-	}
-	if truncateRunes(s, 0) != "" || truncateRunes(s, -1) != "" {
-		t.Fatal("maxRunes<=0 应返回空串")
-	}
-	if truncateRunes("短", 10) != "短" {
-		t.Fatal("短串应原样返回")
-	}
-	// 关键回归：旧实现 content[:30] 是字节切，中文会切出半个字符（utf8.RuneError）
-	if got := truncateRunes("中文标题测试内容很长很长很长很长很长很长", 8); !utf8.ValidString(got) {
-		t.Fatalf("rune 截断后仍不是合法 UTF-8: %q", got)
-	}
-}
-
-func TestTruncate_RuneCounted(t *testing.T) {
-	s := strings.Repeat("记", 40) // 120 字节；旧实现 s[:10] 只能得到 3 个半截汉字
-	got := truncate(s, 10)
-	want := strings.Repeat("记", 10) + "..."
-	if got != want {
-		t.Fatalf("truncate = %q, want %q", got, want)
-	}
-	if !utf8.ValidString(got) {
-		t.Fatal("truncate 结果不是合法 UTF-8")
-	}
-	if truncate("短内容", 60) != "短内容" {
-		t.Fatal("未超长应原样返回")
-	}
-}
-
-func TestShortHash_Deterministic(t *testing.T) {
-	a, b := shortHash("同一段内容"), shortHash("同一段内容")
-	if a != b {
-		t.Fatal("shortHash 必须稳定")
-	}
-	if len(a) != 8 {
-		t.Fatalf("shortHash 长度应为 8，得到 %d", len(a))
-	}
-	if shortHash("内容甲") == shortHash("内容乙") {
-		t.Fatal("不同内容不该同哈希")
-	}
-}
-
-// 端到端：真的落盘，检查文件名可读、无乱码、同名不互相覆盖。
-func TestPushToObsidian_ReadableFilenames(t *testing.T) {
-	dir := t.TempDir()
-	s := NewObsidianSyncer(dir, nil)
-
-	dupPrefix := "同一段开头的内容 abcdefghijklmnopqrstuvwxyz"
-	mems := []map[string]interface{}{
-		{"id": "mem_1", "category": "distilled", "quality_score": 0.9,
-			"content": "修复了 respond 重复声明问题"},
-		{"id": "mem_2", "category": "distilled", "quality_score": 0.8,
-			"content": "LanceDB 已设天花板，不会再膨胀到 35G"},
-		// 前 30 个 rune 完全相同 → 必须加哈希后缀而不是覆盖
-		{"id": "mem_3", "category": "distilled", "content": dupPrefix + " 变体一"},
-		{"id": "mem_4", "category": "distilled", "content": dupPrefix + " 变体二"},
-	}
-
-	if err := s.PushToObsidian(mems, "mirror"); err != nil {
-		t.Fatalf("PushToObsidian 失败: %v", err)
-	}
-
-	entries, err := os.ReadDir(filepath.Join(dir, "mirror"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(entries) != len(mems) {
-		t.Fatalf("应写入 %d 个文件（含撞名消歧），实际 %d 个：%v", len(mems), len(entries), names(entries))
-	}
-	t.Logf("实际落盘文件名: %v", names(entries))
-
-	for _, e := range entries {
-		n := e.Name()
-		if strings.Contains(n, "____") {
-			t.Errorf("文件名出现下划线乱码: %q", n)
-		}
-		if !strings.ContainsAny(n, "修复了重复声明问题磁盘排查天花板膨胀同一段") {
-			t.Errorf("文件名丢失中文标题: %q", n)
-		}
-		if !utf8.ValidString(n) {
-			t.Errorf("文件名不是合法 UTF-8: %q", n)
-		}
-		data, err := os.ReadFile(filepath.Join(dir, "mirror", n))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !utf8.Valid(data) {
-			t.Errorf("文件内容不是合法 UTF-8: %q", n)
-		}
-		if !strings.Contains(string(data), "由织忆 MemoryWeave 同步") {
-			t.Errorf("缺少同步 footer: %q", n)
-		}
-	}
-
-	// 撞名消歧：两条同前缀记忆都要落盘（4 个文件已证明没互相覆盖）
-	var suffixed int
-	for _, e := range entries {
-		if strings.Contains(e.Name(), dupPrefix[:12]) && strings.Contains(e.Name(), "-") {
-			suffixed++
-		}
-	}
-	if suffixed != 1 {
-		t.Errorf("应恰好 1 个文件带哈希后缀消歧，实际 %d：%v", suffixed, names(entries))
-	}
-}
-
-func names(entries []os.DirEntry) []string {
-	out := make([]string, 0, len(entries))
-	for _, e := range entries {
-		out = append(out, e.Name())
-	}
-	return out
-}
-
-// ─── 2026-09-10 P0：文件名不得带凭证 ───────────────────────
-
-func TestSanitizeFilename_RedactsSecret(t *testing.T) {
-	const fakeKey = "tskey-auth-kTESTONLY0000000000000000000000000000000000000"
-	got := sanitizeFilename("authkey " + fakeKey)
-	if got == "" {
-		t.Fatal("脱敏后不应为空（占位符仍可读）")
-	}
-	if strings.Contains(got, "tskey-auth-kTESTONLY") {
-		t.Errorf("文件名仍含凭证: %q", got)
-	}
-	if strings.Contains(got, "/") || strings.Contains(got, string(os.PathSeparator)) {
-		t.Errorf("文件名仍含路径分隔符: %q", got)
-	}
-}

go/internal/api/routes/provenance_observe.go

@@ -1,238 +0,0 @@
-// 织忆 MemoryWeave — commit 写入的「引用可复算」旁路观测（阶段 1→2：只观测，不拦截）
-//
-// 动机（t_3fbb6cbd）：Akasha 的确定性校验器（sourceRange + quoteHash，fail-closed）
-// 是唯一值得移植的东西。织忆现在的写入无法回证（09-25 实测卡点）。
-// 但现有写入方 payload 里没有 source_uri/quote/quote_sha256，直接上硬闸 = 拒掉 100%
-// 写入 = 掐死织忆全量摄取。所以本卡只做观测，先拿真实分布，再决定阈值/形态。
-//
-// 开关：ZHIYI_COMMIT_PROVENANCE_OBSERVE，默认关闭。关闭时行为与改前完全一致（零影响）。
-// 开启时对每次 commit 做旁路观测（异步 goroutine，不阻塞、不改响应、不改写入路径），
-// 结果追加到 ~/.hermes/logs/zhiyi-commit-provenance/YYYY-MM-DD.jsonl。
-//
-// 判定降级（AC2 重定义，t_dc412532 阶段2 设计输入）：
-//
-//	(a) metadata 有 source_uri + quote + quote_sha256 → 复算 sha256(quote) 比对；
-//	    不等 observable=false, reason=hash_mismatch
-//	(b) 无上述字段但 source=="session-compress" 且 session_id 存在 →
-//	    去 ~/.hermes/state.db（只读）取该 session 消息文本做回证。
-//	    观察期实测（n=205, 24h）：true=1 / false=8 / unknown=193；全部 8 条 false
-//	    均来自 session-compress —— 判据「前 60 字逐字命中 / LCS≥60」对「摘要/派生内容」
-//	    结构性必 false（摘要不会逐字出现在原文里）。AC2 修正：
-//	      * 原文不可得（session 已压缩/清除）→ observable=unknown, reason=source_not_available
-//	        （空原文 = 无法证伪，不是证伪失败 —— 旧逻辑误标 false/not_in_source）
-//	      * 前 60 字逐字命中 或 LCS≥60 → observable=true（引用片段可溯源）
-//	      * 其余（摘要低 LCS，属正常改写）→ observable=unknown, reason=derived_low_lcs
-//	        （对派生内容无法证伪 —— 摘要重述≠不可溯源）
-//	    同时把实测数值 lcs_len / prefix_hit60 写进 jsonl（AC1 先量后判），
-//	    供阶段3 转硬闸时按分布定档。
-//	(c) 其他 source → observable=unknown, reason=no_derivation（不要瞎猜成 false）
-package routes
-
-import (
-	"crypto/sha256"
-	"database/sql"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"time"
-
-	_ "modernc.org/sqlite"
-)
-
-// observeMu 保护 jsonl 追加（commit 并发时防交错写）
-var observeMu sync.Mutex
-
-// provenanceObserveEnabled 开关（默认关闭，读一次即可）
-var provenanceObserveEnabled = os.Getenv("ZHIYI_COMMIT_PROVENANCE_OBSERVE") == "1" ||
-	strings.EqualFold(os.Getenv("ZHIYI_COMMIT_PROVENANCE_OBSERVE"), "true")
-
-// stateDBPath 只读来源库（session-to-zhiyi.py 等写入方读的同一个 state.db）
-const stateDBPath = "/home/muc/.hermes/state.db"
-
-// provenanceLogDir 观测结果落盘目录
-const provenanceLogDir = "/home/muc/.hermes/logs/zhiyi-commit-provenance"
-
-// minCommonRun 判定「可溯源」的最长公共子串下界（字符）。
-// 依据（t_dc412532 阶段2 实测分布）：观察期 session-compress 摘要 content_len 均值 ~450，
-// 要求 LCS≥60 取「摘要中至少出现一段可对回原文的片段」，过低会把无关噪声当溯源。
-const minCommonRun = 60
-
-// observeCommitProvenance 旁路观测一次 commit（异步调用，永不阻塞写路径）
-func observeCommitProvenance(agentID, content string, metadata map[string]any) {
-	if !provenanceObserveEnabled {
-		return
-	}
-	source := ""
-	sessionID := ""
-	if metadata != nil {
-		if s, ok := metadata["source"].(string); ok {
-			source = s
-		}
-		if sid, ok := metadata["session_id"].(string); ok {
-			sessionID = sid
-		}
-	}
-
-	observable := "unknown"
-	reason := "no_derivation"
-	lcsLen := 0
-	prefixHit60 := false
-
-	// (a) 显式 quote + hash
-	if metadata != nil {
-		uri, _ := metadata["source_uri"].(string)
-		quote, _ := metadata["quote"].(string)
-		qh, _ := metadata["quote_sha256"].(string)
-		if uri != "" && quote != "" && qh != "" {
-			observable, reason = decideQuoteHash(quote, qh)
-		} else if source == "session-compress" && sessionID != "" {
-			// (b) session-compress：去 state.db 只读回证
-			observable, reason, lcsLen, prefixHit60 = observeViaSession(content, sessionID)
-		}
-	} else if source == "session-compress" && sessionID != "" {
-		observable, reason, lcsLen, prefixHit60 = observeViaSession(content, sessionID)
-	}
-
-	// (c) 其余保持 unknown / no_derivation
-
-	line := map[string]interface{}{
-		"ts":           time.Now().Format(time.RFC3339),
-		"agent_id":     agentID,
-		"source":       source,
-		"session_id":   sessionID,
-		"observable":   observable,
-		"reason":       reason,
-		"content_len":  len(content),
-		"lcs_len":      lcsLen,      // AC1: content 与原文的最长公共子串长度（实测数值）
-		"prefix_hit60": prefixHit60, // AC1: 前 60 字是否逐字命中原文
-	}
-	appendProvenanceLog(line)
-}
-
-// decideQuoteHash 复算 sha256(quote) 与调用方声明的 quote_sha256 比对。
-func decideQuoteHash(quote, quoteSHA256 string) (string, string) {
-	sum := sha256.Sum256([]byte(quote))
-	if hex.EncodeToString(sum[:]) == quoteSHA256 {
-		return "true", ""
-	}
-	return "false", "hash_mismatch"
-}
-
-// observeViaSession 去 state.db（只读）取 session 消息文本，回证 content 可溯源。
-// 返回 (observable, reason, lcs_len, prefix_hit60)。
-// AC2 语义：对派生/摘要内容不做逐字强判 —— 原文不可得→unknown（无法证伪），
-// 命中→true（片段可溯源），低 LCS→unknown（摘要改写正常，不可证伪）。
-func observeViaSession(content, sessionID string) (string, string, int, bool) {
-	db, err := sql.Open("sqlite", "file:"+stateDBPath+"?_pragma=query_only(1)&_pragma=busy_timeout(3000)")
-	if err != nil {
-		return "unknown", "state_db_open_failed: " + err.Error(), 0, false
-	}
-	defer db.Close()
-	rows, err := db.Query(
-		"SELECT content FROM messages WHERE session_id=? AND role IN ('user','assistant') ORDER BY id",
-		sessionID)
-	if err != nil {
-		return "unknown", "state_db_query_failed: " + err.Error(), 0, false
-	}
-	defer rows.Close()
-
-	var sb strings.Builder
-	for rows.Next() {
-		var msg string
-		if err := rows.Scan(&msg); err != nil {
-			continue
-		}
-		sb.WriteString(msg)
-		sb.WriteByte('\n')
-	}
-	srcText := sb.String()
-	if srcText == "" {
-		// 原文不可得：无法证伪，不是证伪失败（旧逻辑误标 false/not_in_source）
-		return "unknown", "source_not_available", 0, false
-	}
-	match, lcsLen, prefixHit60 := provenanceMeasure(content, srcText)
-	if match {
-		return "true", "", lcsLen, prefixHit60
-	}
-	// 摘要/派生内容低 LCS 属正常改写，无法证伪 —— 不算 false
-	return "unknown", "derived_low_lcs", lcsLen, prefixHit60
-}
-
-// provenanceMeasure 计算 content 相对 srcText 的可溯源实测指标：
-//
-//	prefixHit60 = content 前 60 字在 srcText 中逐字命中
-//	lcsLen      = content 与 srcText 的最长公共子串长度
-//	match       = prefixHit60 || lcsLen >= minCommonRun
-func provenanceMeasure(content, srcText string) (match bool, lcsLen int, prefixHit60 bool) {
-	if content == "" || srcText == "" {
-		return false, 0, false
-	}
-	first := content
-	if len(first) > minCommonRun {
-		first = first[:minCommonRun]
-	}
-	prefixHit60 = strings.Contains(srcText, first)
-	// LCS 兜底（受限输入防打爆）
-	c := content
-	if len(c) > 2000 {
-		c = c[:2000]
-	}
-	s := srcText
-	if len(s) > 20000 {
-		s = s[:20000]
-	}
-	lcsLen = lcsLength(c, s)
-	return prefixHit60 || lcsLen >= minCommonRun, lcsLen, prefixHit60
-}
-
-// lcsLength 两个字符串的最长公共子串长度（O(n*m) 动态规划，取较短者做列）。
-func lcsLength(a, b string) int {
-	if len(a) == 0 || len(b) == 0 {
-		return 0
-	}
-	// 让 b 为较短者（节省列空间）
-	if len(b) > len(a) {
-		a, b = b, a
-	}
-	prev := make([]int, len(b)+1)
-	cur := make([]int, len(b)+1)
-	best := 0
-	for i := 1; i <= len(a); i++ {
-		for j := 1; j <= len(b); j++ {
-			if a[i-1] == b[j-1] {
-				cur[j] = prev[j-1] + 1
-				if cur[j] > best {
-					best = cur[j]
-				}
-			} else {
-				cur[j] = 0
-			}
-		}
-		prev, cur = cur, prev
-	}
-	return best
-}
-
-// appendProvenanceLog 把一行观测结果追加到当日 jsonl。
-func appendProvenanceLog(line map[string]interface{}) {
-	observeMu.Lock()
-	defer observeMu.Unlock()
-	data, err := json.Marshal(line)
-	if err != nil {
-		return
-	}
-	if err := os.MkdirAll(provenanceLogDir, 0o755); err != nil {
-		return
-	}
-	path := filepath.Join(provenanceLogDir, time.Now().Format("2006-01-02")+".jsonl")
-	f, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0o644)
-	if err != nil {
-		return
-	}
-	defer f.Close()
-	fmt.Fprintf(f, "%s\n", data)
-}

go/internal/api/routes/provenance_observe_test.go

@@ -1,49 +0,0 @@
-package routes
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"strings"
-	"testing"
-)
-
-func TestProvenanceMatch(t *testing.T) {
-	src := strings.Repeat("源文本", 50) // 150 chars
-	// 前60字符逐字命中
-	content := strings.Repeat("源文本", 25) // 75 chars
-	if m, _, _ := provenanceMeasure(content, src); !m {
-		t.Fatal("expect first-60-chars substring match")
-	}
-	// 完全无关 → false
-	if m, _, _ := provenanceMeasure(strings.Repeat("完全无关", 20), src); m {
-		t.Fatal("expect no match for unrelated")
-	}
-	// LCS >= 60 兜底（content 中间有长公共段）
-	content2 := strings.Repeat("P", 10) + strings.Repeat("源文本", 40) + strings.Repeat("Q", 5)
-	src2 := strings.Repeat("A", 30) + strings.Repeat("源文本", 40) + strings.Repeat("B", 30)
-	if m, _, _ := provenanceMeasure(content2, src2); !m {
-		t.Fatal("expect LCS>=60 fallback match")
-	}
-}
-
-func TestLCSLength(t *testing.T) {
-	if got := lcsLength("abcde", "abfce"); got != 2 { // "ab"
-		t.Fatalf("lcs=2 expect, got %d", got)
-	}
-	if got := lcsLength("", "abc"); got != 0 {
-		t.Fatalf("lcs empty=0 expect, got %d", got)
-	}
-}
-
-func TestDecideQuoteHash(t *testing.T) {
-	quote := "这段引用内容"
-	sum := sha256.Sum256([]byte(quote))
-	observable, reason := decideQuoteHash(quote, hex.EncodeToString(sum[:]))
-	if observable != "true" || reason != "" {
-		t.Fatalf("expect true/'' got %s/%s", observable, reason)
-	}
-	observable, reason = decideQuoteHash(quote, strings.Repeat("0", 64))
-	if observable != "false" || reason != "hash_mismatch" {
-		t.Fatalf("expect false/hash_mismatch got %s/%s", observable, reason)
-	}
-}