@hupan56/wlkj 3.1.32 → 3.3.0

package/templates/qoder/hooks/post-tool-use.py

@@ -107,6 +107,42 @@ def _dev():
     return None
 
 
+def _auto_learn_from_prd(prd_path):
+    """PRD 写完后自动调 MCP learn 沉淀业务规则（宿主能力接入）。
+
+    读 PRD 标题 → 调工作台 MCP learn → 知识层自动积累。
+    失败静默（铁律：hook 崩溃不阻塞会话）。
+    """
+    try:
+        title = os.path.basename(prd_path).replace('.md', '')
+        # 读 mcp_config 拿 token
+        cfg_path = os.path.join(BASE, 'wlinkj-workflow', 'mcp_config.json')
+        if not os.path.isfile(cfg_path):
+            return
+        import json as _j
+        cfg = _j.load(open(cfg_path, encoding='utf-8'))
+        srv = cfg.get('mcpServers', {}).get('wlinkj-knowledge', {})
+        token = srv.get('token', '')
+        url = srv.get('url', '').replace('/mcp', '/mcp')  # 保持 /mcp
+        pid = srv.get('env', {}).get('WLKJ_PROJECT_ID', '')
+        if not token or not url or not pid:
+            return
+        # 调 MCP learn（POST /mcp JSON-RPC）
+        import urllib.request
+        rpc = {"jsonrpc": "2.0", "id": 1, "method": "tools/call",
+               "params": {"name": "learn",
+                          "arguments": {"project_id": pid, "category": "decision",
+                                        "pattern": "PRD更新: " + title,
+                                        "source": "qoder-hook-auto"}}}
+        req = urllib.request.Request(
+            url, data=_j.dumps(rpc).encode(),
+            headers={"Content-Type": "application/json", "X-MCP-Token": token},
+            method="POST")
+        urllib.request.urlopen(req, timeout=5).read()  # 5s 超时，不阻塞
+    except Exception:
+        pass  # 铁律：静默
+
+
 def _append_event(event, data):
     """best-effort append 一条事件到当前 dev 的 feedback.jsonl。避开 learn import 断链, 直接写文件。"""
     try:
@@ -128,10 +164,30 @@ def _append_event(event, data):
         pass  # 铁律: 埋点失败绝不阻塞
 
 
+def _log_tool_call(tool_name):
+    """轻量记录每次工具调用到独立日志 tool-calls.jsonl（不混入 feedback.jsonl）。
+
+    为'思考链过长/调用过多'校准积累数据：事后按时间窗口聚合算每 turn 调用次数分布。
+    纯统计，不阻断不提示。turn 内累计留给分析层算（避免跨进程状态机复杂化）。
+    """
+    try:
+        dev = _dev() or 'unknown'
+        log_file = os.path.join(BASE, 'workspace', 'members', dev, 'journal', 'tool-calls.jsonl')
+        os.makedirs(os.path.dirname(log_file), exist_ok=True)
+        with open(log_file, 'a', encoding='utf-8') as f:
+            f.write(json.dumps({
+                'ts': datetime.now().isoformat(timespec='seconds'),
+                'tool': (tool_name or 'unknown').lower(),
+            }, ensure_ascii=False) + '\n')
+    except Exception:
+        pass
+
+
 def main():
     try:
         tool_input, tool_name = _read_tool_info()
         tn = (tool_name or '').lower()
+        _log_tool_call(tool_name)  # 轻量调用计数(独立日志,不阻断), 为'思考链过长'校准积累数据
 
         # 1. Write/Edit 落到 PRD / task.json → 埋点
         if tn in WRITE_TOOLS or tn == 'bash':
@@ -140,8 +196,13 @@ def main():
                 plow = p.lower().replace('\\', '/')
                 if 'prd' in os.path.basename(plow).lower() and plow.endswith('.md'):
                     _append_event('prd_written', {'prd': os.path.basename(p), 'tool': tool_name})
+                    # ★ 宿主能力接入：PRD 写完 → 自动调 MCP learn 沉淀业务规则
+                    _auto_learn_from_prd(p)
                 if plow.endswith('task.json'):
                     _append_event('task_touched', {'task_json': os.path.basename(os.path.dirname(p)), 'tool': tool_name})
+                # ★ 宿主能力接入：代码文件改完 → 自动记 code_changed（知识层下次检测过时用）
+                if any(plow.endswith(ext) for ext in ('.java', '.vue', '.ts', '.js', '.py')):
+                    _append_event('code_changed', {'file': os.path.basename(p), 'path': plow[:200]})
                 # v3.1 软提示: prototype HTML 写完但缺来源锚定 → stderr 提醒(不阻断)
                 if 'prototype' in os.path.basename(plow) and plow.endswith('.html'):
                     try:

package/templates/qoder/hooks/session-start.py

@@ -134,7 +134,7 @@ def get_index_info():
         pass
 
     lines.append('## Knowledge Graph')
-    lines.append('MCP工具 (QoderWork自动调用): search_code / get_impact / coverage_matrix / get_workflow 等17个')
+    lines.append('MCP工具 (Qoder/QoderWork自动调用): search_code / rag_search / get_impact / project_brief / graphrag_ask 等43个')
     lines.append('  python .qoder/scripts/orchestration/wlkj.py search <keyword> [--platform web|app]')
     lines.append('  python .qoder/scripts/orchestration/wlkj.py context <keyword>   # 一次打包全部上下文')
 
@@ -149,72 +149,40 @@ def get_index_info():
                     role = _line.split('=', 1)[1].strip()
     except Exception:
         pass
-    db_path = os.path.join(BASE, 'data', 'index', 'kg.duckdb')
-
-    if os.path.isfile(db_path):
-        import time as _time
-        db_mtime = os.path.getmtime(db_path)
-        db_age_hours = (_time.time() - db_mtime) / 3600
-
-        # 检查代码是否比 DuckDB 新 (采样几个文件)
-        code_dir = os.path.join(BASE, 'data', 'code')
-        code_newer = False
-        if os.path.isdir(code_dir):
-            for root, dirs, files in os.walk(code_dir):
-                dirs[:] = [d for d in dirs if d not in ('node_modules', '.git', 'dist', '__pycache__')]
-                depth = root[len(code_dir):].count(os.sep)
-                if depth >= 3:
-                    dirs[:] = []
-                    continue
-                for fn in files:
-                    if fn.endswith(('.vue', '.java', '.ts')):
-                        try:
-                            if os.path.getmtime(os.path.join(root, fn)) > db_mtime:
-                                code_newer = True
-                                break
-                        except OSError:
-                            pass
-                if code_newer:
-                    break
-
-        lines.append('  kg.duckdb: %.0f小时前构建' % db_age_hours)
-
-        if role in ('admin', 'dev'):
-            # 管理员/开发: 能构建
-            if code_newer or db_age_hours > 168:  # 7天 = 168小时
-                lines.append('  [WARN] 知识图谱过期! 代码有新变更.')
-                lines.append('  → 管理员请运行: python .qoder/scripts/kg/kg_build.py')
-                lines.append('  → 完成后: python .qoder/scripts/orchestration/wlkj.py sync push (共享给团队)')
-            else:
-                lines.append('  ✓ 知识图谱最新')
-        else:
-            # 非管理员: 只拉取
-            if code_newer or db_age_hours > 168:
-                lines.append('  [WARN] 知识图谱可能过期.')
-                lines.append('  → 运行: python .qoder/scripts/orchestration/wlkj.py sync pull (获取管理员最新构建)')
-            else:
-                lines.append('  ✓ 知识图谱最新')
-
-        # 检查是否有未标注的模块 (提示AI做语义标注)
-        try:
-            import subprocess as _sp
-            # v3.x: kg_semantic.py 已迁移到 domain/kg/graph/ (旧扁平路径不存在)
-            r = _sp.run([sys.executable, os.path.join(BASE, '.qoder', 'scripts', 'domain', 'kg', 'graph', 'kg_semantic.py'), '--check'],
-                        capture_output=True, text=True, encoding='utf-8', timeout=5)
-            if r.stdout and 'semantic_labeling_needed' in r.stdout:
-                import json as _json
-                data = _json.loads(r.stdout)
-                unlabeled = len(data.get('modules', []))
-                if unlabeled > 0:
-                    lines.append('  [提示] %d个模块未标注中文名, 运行 kg_semantic.py --check 查看' % unlabeled)
-        except Exception:
-            pass
+    # ★ 知识层健康检查：全迁 PG 后不再检查本地 kg.duckdb（已删除），改探活 MCP 知识层。
+    # 复用 wlinkj-workflow/mcp_config.json 的 token+url，调 get_knowledge_health 拿真实健康分。
+    # best-effort：任何失败都不阻塞会话启动（与其它 hook 铁律一致）。
+    kg_info = None
+    try:
+        import json as _json
+        import urllib.request as _url
+        cfg_path = os.path.join(BASE, 'wlinkj-workflow', 'mcp_config.json')
+        if os.path.isfile(cfg_path):
+            _cfg = _json.load(open(cfg_path, encoding='utf-8'))
+            _srv = _cfg.get('mcpServers', {}).get('wlinkj-knowledge', {})
+            _url_s = _srv.get('url', '')
+            _tok = _srv.get('token', '')
+            if _url_s and _tok and _url_s != 'WILL_BE_FILLED_BY_WL_INIT':
+                _rpc = {"jsonrpc": "2.0", "id": 1, "method": "tools/call",
+                        "params": {"name": "get_knowledge_health", "arguments": {}}}
+                _req = _url.Request(_url_s, data=_json.dumps(_rpc).encode(),
+                                    headers={"Content-Type": "application/json",
+                                             "X-MCP-Token": _tok}, method="POST")
+                _resp = _url.urlopen(_req, timeout=4).read()
+                kg_info = _json.loads(_json.loads(_resp)["result"]["content"][0]["text"])
+    except Exception:
+        kg_info = None
+
+    if kg_info and isinstance(kg_info, dict) and "error" not in kg_info:
+        lines.append('  ✓ 知识层在线 (PG@5432): 健康分 %s / 覆盖 %s / 新鲜 %s / 完整 %s' % (
+            kg_info.get("score", "?"), kg_info.get("coverage", "?"),
+            kg_info.get("freshness", "?"), kg_info.get("completeness", "?")))
+        issues = kg_info.get("issues", []) or []
+        if issues and role in ('admin', 'dev'):
+            lines.append('  [提示] 健康问题: ' + '; '.join(str(i)[:60] for i in issues[:2]))
     else:
-        lines.append('  [MISSING] kg.duckdb 不存在!')
-        if role in ('admin', 'dev'):
-            lines.append('  → 运行: python .qoder/scripts/kg/kg_build.py')
-        else:
-            lines.append('  → 运行: python .qoder/scripts/orchestration/wlkj.py sync pull')
+        lines.append('  [WARN] 知识层未响应（MCP 后端未启动？）')
+        lines.append('  → 启动: cd wlinkj-workspace && start_pg.bat（后端 :10010）')
 
     return NL.join(lines)
 

package/templates/qoder/hooks/stop-eval.py

@@ -105,6 +105,35 @@ def _recent_prd_files():
     return candidates
 
 
+# 快速模式 6 章必需标题 (与 prd-quick-template.md 对齐)
+QUICK_REQUIRED_SECTIONS = [
+    '功能入口', '需求背景', '需求说明', '影响范围', '验收标准', '不在本次范围',
+]
+
+
+def _check_quick_prd_complete(prd_path):
+    """检测 quick 模式 PRD 是否缺章。返回缺失章节列表 (空=完整)。
+
+    判定 quick 模式: @contract 头含 mode: quick。
+    必需 6 章: 功能入口/需求背景/需求说明/影响范围/验收标准/不在本次范围。
+    治"残废品" (真实案例: 海外考勤 PRD 只写"功能入口"一段, 6 章缺 5 章)。
+    """
+    try:
+        text = open(prd_path, encoding='utf-8', errors='replace').read()
+    except Exception:
+        return []  # 读不到不拦 (误拦比放过更糟)
+    # 只检 quick 模式 (完整档 13 章另算, 不在此 hook 范围)
+    if 'mode: quick' not in text[:500]:
+        return []
+    missing = []
+    for sec in QUICK_REQUIRED_SECTIONS:
+        # 章节标题: ## 功能入口 / ## 需求背景 等 (允许前后空格)
+        import re
+        if not re.search(r'^#{1,3}\s*' + sec, text, re.MULTILINE):
+            missing.append(sec)
+    return missing
+
+
 def _evald_prds():
     """读 eval-history.jsonl, 返回【已通过门禁】的 prd 文件名集合。
 
@@ -161,6 +190,24 @@ def main():
         recent = _recent_prd_files()
         if not recent:
             sys.exit(0)  # 本轮没产 PRD, 放行
+
+        # ── 先查 quick 模式 PRD 缺章 (残废品门禁, 比 eval 更优先) ──
+        incomplete = []
+        for p in recent:
+            miss = _check_quick_prd_complete(p)
+            if miss:
+                incomplete.append((p, miss))
+        if incomplete:
+            lines = []
+            for p, miss in incomplete[:3]:
+                lines.append('  %s 缺: %s' % (os.path.basename(p), '、'.join(miss)))
+            sys.stderr.write(
+                '【PRD 残废品门禁】检测到快速模式 PRD 缺章 (6 章缺一不可):\n'
+                + '\n'.join(lines) + '\n'
+                '修复: 补齐缺失章节的标题和内容 (不涉及的写一句话说明, 标题必须保留),\n'
+                '      章节顺序: 功能入口/需求背景/需求说明/影响范围/验收标准/不在本次范围。\n'
+                '      模板: .qoder/templates/prd-quick-template.md\n')
+            sys.exit(2)
         evald = _evald_prds()
         last_records = _last_record_by_prd()
         # 区分两种未过门禁: 从没跑过 eval / 跑了但没过线

package/templates/qoder/rules/wl-pipeline.md

@@ -53,6 +53,19 @@ test -f .qoder/.developer && echo "已初始化" || echo "未初始化"
 注意：用户说"同步/保存产出"通常指 team_sync（push），不是 git commit；
 用户说"提交/commit 代码"才是 wl-commit。
 
+## 规则 0.3：命令路由是最终决定（最高优先级，记忆/偏好不可覆盖）
+
+**用户明确打了 `/wl-X` → 就走 X，绝不改道。** 这一条优先级高于一切（包括"问平台"），
+任何"用户偏好""历史记忆""上下文暗示"都不可覆盖当前明确的命令。命令名 = 最终路由。
+
+- 用户打 `/wl-prd`（哪怕描述像 bug："无法提交，时间报错"）→ **必须走 PRD**（为修复写需求），**不准**跑去 `/wl-test` / `/wl-code` / 排查
+- 用户打 `/wl-code` → 走代码；`/wl-test` → 走测试；`/wl-task` → 走任务；其它命令同理
+- 判断不了路由 → **问用户一句**，不要凭"偏好/记忆"自己猜
+
+> 🚫 反面教材（禁止，真实案例）：用户打 `/wl-prd 快速，园林绿化养护计划无法提交，时间有问题报错`，
+> AI 因"记忆里用户偏好报bug走test"擅自改道 `/wl-test` → **违规**。命令是 `/wl-prd`，描述像 bug 也走 PRD
+> （`wl-prd.md` 命令优先铁律连这个例子都举了）。"偏好/记忆"绝不可覆盖用户当前明确的命令。
+
 ## 规则 0.5：数据库查询必须先问环境（安全红线，问了就停）
 
 AI 检测到需要查询**真实数据库**（调用 `mcp__qoder-mysql` 的 query_schema / query_data /
@@ -132,6 +145,30 @@ kg.py context（= context_pack）一条命令返回：相关代码文件 + 同
 > 这是工作流比原生慢的根因——原生 AI 本能地并发，工作流却被"逐步执行"的文档节奏带成了串行。
 > 把串行变并发，同样工作量耗时可砍到 1/3。MCP server（kg/mysql/zentao）都支持 JSON-RPC 并发请求。
 
+## 规则 2.6：思考链收敛——先取证再推理（治"超长思考链"）
+
+**痛点：AI 取证了（读了代码）却没抓住矛盾，在假设上连续空转，15+ 步才定位 3 步能找到的根因。**
+> ⚠️ 本规则**只约束排查/修码/取证类推理**；**探索/规划/写PRD** 类（用 feature/workflow/coverage/context 撒网理解业务）不受约束，反而要多用 kg。
+
+### 2.6.1 先取证再推理（铁律）
+每个推断必须立刻验证，**不许"假设A → 假设B → 假设C"连环空转**；验证不了就换方向。
+**一轮工具调用 = 一轮推理**，不许"无工具调用的纯思考"超过 1 轮。
+
+### 2.6.2 取证优先用知识层（kg 比 grep 快 10 倍，与规则 2 一脉相承）
+- 相关代码文件 → `context_pack` 列文件（**别** grep 全库找）
+- 字段真实类型/命名 → `query_schema` / `field_map` / `db_columns`（**别** Read 整个 Entity 翻）
+- 改动波及面 → `table_impact` / `get_impact`（**别** 手动追踪调用链）
+- API 路由/参数 → `code-api` 索引（**别** grep Controller）
+→ **kg 给了文件才 Read 那几个；kg 给了类型就不读全文。kg 用得更准，不是闲置。**
+
+### 2.6.3 排查/修码类先对齐链路（1-2 步对齐，再动手；kg 一次对齐多环）
+- **后端报错/类型异常**：`query_schema`(DB列类型) + `context_pack`(BO/Entity文件) → Read 对齐 → 找不一致点
+- **接口不通/400**：`code-api`(路由/参数) + `table_impact`(影响面)
+- **前端白屏/NaN**：`context_pack`(组件/API) + `field_map`(字段映射)
+
+> 正例：`query_schema` 得 DB列=Date + `context_pack` 得 BO=String → "类型不一致，改BO"（2步定位）
+> 反例：假设null → 假设Invalid Date → 假设时区 → 假设disabledDate → …（15步空转，养护计划实录）
+
 ## 规则 3：原型风格必须来自真源（含图标）
 
 - 起点永远是平台模板：.qoder/templates/prototype-web.html / prototype-app.html

package/templates/qoder/scripts/capability/adapters/__init__.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 """
-nexus.adapters —— 各宿主/降级路径的 Cap 实现。
+capability.adapters —— 各宿主/降级路径的 Cap 实现。
 
 设计模式: Adapter + Bridge（Cap 抽象 × 宿主实现 正交）
 

package/templates/qoder/scripts/capability/adapters/mcp.py

@@ -23,7 +23,7 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
-from ..registry_mcp import McpRegistry
+from ..registry_mcp import McpRegistry, _load_servers
 from protocol.transports import ToolResult
 
 
@@ -42,7 +42,7 @@ class McpCap:
     """L1 MCP 能力统一入口 —— 复用已有 MCP server（禅道/知识图谱/MySQL/蓝湖）。
 
     工作流调用：
-        cap = nexus.resolve()
+        cap = resolve()
         result = cap.mcp.call("search_code", {"keyword": "保险"})
         # 自动路由：MCP 可用走 MCP，不可用走 wlkj.py（CLI 降级）
     """
@@ -54,8 +54,9 @@ class McpCap:
         # spawn 子进程, 不依赖宿主是否原生支持 MCP —— CLI / Codex / Claude 同样能起 server。
         # 故: 宿主未声明 mcp_servers 或声明为空 = "没有宿主原生限制, 用全部本地可起的"。
         if mcp_servers:  # 非空列表才过滤
-            from ..registry_mcp import SERVERS
-            filtered = {k: v for k, v in SERVERS.items() if k in mcp_servers}
+            # 用 _load_servers() 而非硬编码 SERVERS —— 这样 mcp_config.json 改配置才生效
+            all_servers = _load_servers()
+            filtered = {k: v for k, v in all_servers.items() if k in mcp_servers}
             self._registry = McpRegistry(servers=filtered)
         else:
             self._registry = _get_registry()
@@ -117,6 +118,12 @@ class McpCap:
         "search_wiki":       ("kg", ["wiki"]),
         "fill_prototype":    ("kg", ["fill-prototype"]),
         "get_design_system": ("kg", ["design-system"]),
+        # RAG/GraphRAG 降级映射（MCP 挂时走本地 wlkj.py kg search，语义降级为关键词）
+        "rag_search":        ("kg", ["search"]),
+        "ask_corpus":        ("kg", ["search"]),
+        # 学习工具降级（MCP 挂时本地无 learning 表，返回提示）
+        "learn":             ("noop", []),
+        "get_learnings":     ("noop", []),
         "list_tasks":        ("task", ["list"]),
         "create_task":       ("task", ["create"]),
         "start_task":        ("task", ["start"]),
@@ -129,10 +136,16 @@ class McpCap:
         if entry is None:
             return None
         cmd, base_args = entry
+        # noop 类工具（learn/get_learnings 等）：本地无等价 CLI，返回提示不崩
+        if cmd == "noop":
+            return json.dumps({"degraded": True, "message": "MCP不可用，该工具(learning)降级跳过"}, ensure_ascii=False)
         cli_args = list(base_args)
-        # 从 MCP args 构建命令行参数
-        if "keyword" in args:
-            cli_args.append(str(args["keyword"]))
+        # 从 MCP args 构建命令行参数。
+        # 参数名对齐: 平台 MCP search 工具入参是 query, 引擎命令文档用 keyword。
+        # 这里两边都取值, 确保无论上游传哪个都能落到 CLI 查询词上。
+        kw = args.get("keyword") or args.get("query")
+        if kw is not None:
+            cli_args.append(str(kw))
         if "platform" in args and args["platform"]:
             cli_args.extend(["--platform", str(args["platform"])])
         if "role" in args and args["role"]:
@@ -211,128 +224,91 @@ class McpCap:
 
 
 class McpMemoryProvider:
-    """memory 职责链的 MCP provider —— 接通 kg.duckdb learning_events 表。
+    """memory 职责链的 MCP provider —— 接通平台 PG.learning_patterns。
 
-    设计模式: Adapter（把 kg.duckdb 适配成 MemoryCap 契约）
+    设计模式: Adapter（把平台 MCP get_learnings/learn 适配成 MemoryCap 契约）
 
-    职责链位置: 链头优先（available=True），纯 CLI 环境也能用。
-    当 mem0/Zep MCP server 更成熟时，可替换为 MCP 版本，接口不变。
+    职责链位置: 链头优先。平台 MCP 可用（has_tool get_learnings）时抢占，
+    复用项目级学习表（PG.learning_patterns，按 token 解析 pid 隔离，跨会话积累）。
 
-    数据源: kg.duckdb 的 learning_events 表（id, ts, dev, event, data）。
-    复用 learn_aggregate.py 的写入逻辑，保证 CLI 和 MCP 行为一致。
+    数据源: 平台 MCP 工具 get_learnings / learn（后端 services.knowledge.learn）。
     """
 
     def __init__(self):
-        self._available: bool | None = None  # 懒探测
+        self._registry = None  # 懒取 MCP 单例（避免 import 时即连后端）
+
+    def _reg(self):
+        """复用 McpCap 同款模块级单例（_get_registry），零重复 spawn。"""
+        if self._registry is None:
+            self._registry = _get_registry()
+        return self._registry
 
     @property
     def available(self) -> bool:
-        """kg.duckdb 存在且可读写即为可用。"""
-        if self._available is None:
-            try:
-                from foundation.protocol.duckdb_conn import get_db
-                con = get_db()
-                con.execute("""CREATE TABLE IF NOT EXISTS learning_events (
-                    id TEXT PRIMARY KEY, ts TEXT NOT NULL, dev TEXT NOT NULL,
-                    event TEXT NOT NULL, data JSON)""")
-                con.close()
-                self._available = True
-            except Exception:
-                self._available = False
-        return self._available
+        """平台 MCP 可用且 get_learnings 工具在索引中即为可用。
+        全迁 PG 后记忆走平台 get_learnings（PG.learning_patterns，按项目隔离）。
+        """
+        try:
+            return self._reg().has_tool("get_learnings")
+        except Exception:
+            return False
 
     def recall(self, query: str) -> list[dict]:
-        """语义检索记忆: 按 event 或 data 模糊匹配。"""
+        """检索记忆: 取平台学习记录，按 query 模糊过滤 pattern/category。"""
         if not self.available:
             return []
         try:
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            rows = con.execute(
-                """SELECT id, ts, dev, event, data FROM learning_events
-                   WHERE event LIKE '%' || ? || '%' OR data LIKE '%' || ? || '%'
-                   ORDER BY ts DESC LIMIT 20""",
-                [query, query],
-            ).fetchall()
-            con.close()
-            return [
-                {"id": r[0], "ts": r[1], "dev": r[2], "event": r[3], "data": r[4]}
-                for r in rows
-            ]
+            import json as _json
+            result = self._reg().call("get_learnings", {"limit": 50})
+            text = getattr(result, "text", "") or ""
+            data = _json.loads(text) if text else {}
+            items = data.get("items", []) if isinstance(data, dict) else []
+            q = (query or "").lower()
+            out = []
+            for it in items:
+                hay = "%s %s" % (it.get("category", ""), it.get("pattern", ""))
+                if not q or q in hay.lower():
+                    out.append({
+                        "event": it.get("category", ""),
+                        "data": it.get("pattern", ""),
+                        "ts": it.get("last_seen", ""),
+                        "dev": ",".join(it.get("source_devs", []) or []),
+                    })
+            return out[:20]
         except Exception:
             return []
 
     def remember(self, key: str, content: str) -> None:
-        """写入一条记忆: 插入 learning_events 表。"""
+        """写入一条记忆: 调平台 learn（PG.learning_patterns 累加）。"""
         if not self.available:
             return
         try:
-            import hashlib
-            import json
-            import time as _time
-            # ⚠ 不能 import init_schema! duckdb_conn 故意不导出它 (领域 DDL 留在各域)。
-            # 旧版 from ...duckdb_conn import init_schema → ImportError → 被下面 except 吞掉
-            # → INSERT 永不执行 → remember() 静默丢全部写入。
-            # learning_events 表已由 self.available 的 CREATE TABLE IF NOT EXISTS 保证存在,
-            # 这里直接 INSERT 即可。
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            eid = hashlib.md5(("%s:%s:%s" % (key, content, _time.time())).encode()).hexdigest()[:16]
-            ts = _time.strftime("%Y-%m-%dT%H:%M:%S")
-            data = json.dumps({"content": content}, ensure_ascii=False)
-            con.execute(
-                "INSERT OR IGNORE INTO learning_events(id, ts, dev, event, data) VALUES (?,?,?,?,?)",
-                [eid, ts, "", key, data],
-            )
-            con.close()
+            self._reg().call("learn", {
+                "category": "rule",
+                "pattern": "%s: %s" % (key, content[:500]),
+                "source": "engine/memory",
+            })
         except Exception:
-            pass
+            pass  # 写入失败不阻塞
 
     def get_fact(self, key: str) -> str | None:
-        """按 event 精确查找，返回 data 字段（JSON 字符串）。"""
-        if not self.available:
-            return None
-        try:
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            row = con.execute(
-                "SELECT data FROM learning_events WHERE event = ? ORDER BY ts DESC LIMIT 1",
-                [key],
-            ).fetchone()
-            con.close()
-            if not row:
-                return None
-            data = row[0]
-            if isinstance(data, str):
-                return data
-            import json as _json
-            return _json.dumps(data, ensure_ascii=False) if data else None
-        except Exception:
-            return None
+        """按 key 取一条事实，无则 None。"""
+        results = self.recall(key)
+        return results[0].get("data") if results else None
 
     def list_recent(self, limit: int = 10) -> list[dict]:
-        """最近 N 条记忆。"""
+        """最近 N 条记忆（平台按 frequency 倒序返回）。"""
         if not self.available:
             return []
         try:
             import json as _json
-            from foundation.protocol.duckdb_conn import get_db
-            con = get_db()
-            rows = con.execute(
-                "SELECT id, ts, dev, event, data FROM learning_events ORDER BY ts DESC LIMIT ?",
-                [limit],
-            ).fetchall()
-            con.close()
-            results = []
-            for r in rows:
-                data = r[4]
-                # DuckDB JSON 列可能返回字符串，需解析
-                if isinstance(data, str):
-                    try:
-                        data = _json.loads(data)
-                    except (_json.JSONDecodeError, TypeError):
-                        data = {"raw": data}
-                results.append({"id": r[0], "ts": r[1], "dev": r[2], "event": r[3], "data": data or {}})
-            return results
+            result = self._reg().call("get_learnings", {"limit": limit})
+            text = getattr(result, "text", "") or ""
+            data = _json.loads(text) if text else {}
+            items = data.get("items", []) if isinstance(data, dict) else []
+            return [{"event": it.get("category", ""), "data": it.get("pattern", ""),
+                     "ts": it.get("last_seen", ""), "dev": ",".join(it.get("source_devs", []) or [])}
+                    for it in items[:limit]]
         except Exception:
             return []
+