kenaz 0.3.10 → 0.3.12

package/core/.specialist/Heimdall/core.yaml

@@ -19,9 +19,7 @@ workflow:
     actions:
       - "解析 trigger 參數（attention / commit SHA / 'scan' / symbol name）"
       - "確認 project_path（必填）"
-      - "synapse_status → 確認 Synapse 可用"
-    on_synapse_unavailable: "輸出 'ᚺ Heimdall: Synapse unavailable. Abort.' 並退出"
-    output: "trigger_type + project_path + synapse_available"
+    output: "trigger_type + project_path"
 
   phase_1_analyze:
     name: "分析掃描"
@@ -32,54 +30,29 @@ workflow:
         description: |
           Primary path — Heimdall ranks recently touched files by git history as its
           starting point instead of running fixed graph queries. Heimdall is the
-          investigator, not the data collector. Touch frequency plus risk-rune density
+          investigator, not the data collector. Touch frequency plus known-risk density
           give a per-file attention score.
         steps:
           - "git log --since=14.days --name-only → rank files by touch count (top 15) → top_files"
           - "for each file in top_files:"
           - "  kenaz_lsp_symbols(file) → main symbols; kenaz_lsp_callers(symbol, depth=2) → blast_radius"
-          - "  synapse_recall(query=file path or symbol, projectPath=project_path) → known_risks"
+          - "  .failure/ + `kenaz learn list` 中與該檔案/symbol 相關的條目 → known_risks"
           - "  合成 finding: cross-reference blast_radius + known_risks"
-          - "  severity 計算: known HIGH risk rune AND >= 3 callers → HIGH, one of them → MEDIUM, else → LOW"
+          - "  severity 計算: known HIGH risk AND >= 3 callers → HIGH, one of them → MEDIUM, else → LOW"
         on_empty: "top_files 為空 → 輸出 clean scan，跳過後續 Phase"
-        fallback: "kenaz_lsp_* 不可用 → 只用 git log + synapse_recall（severity 不含 caller 數）"
+        fallback: "kenaz_lsp_* 不可用 → 只用 git log + Grep（severity 不含 caller 數）"
       commit_trigger:
         - "git diff-tree --no-commit-id --name-only -r COMMIT_SHA → changed_files; kenaz_lsp_symbols(file) → changed_symbols"
         - "for each changed symbol → kenaz_lsp_callers(depth=2) → blast_radius"
-        - "synapse_recall(changed + caller symbols) → known_risks"
+        - ".failure/ + `kenaz learn list` 中與 changed + caller symbols 相關的條目 → known_risks"
         - "交叉比對：known_risks ∩ blast_radius HIGH → 標記高優先"
       scheduled_trigger:
-        - "synapse_recall('risk security performance') → active_runes"
-        - "比對 active_runes 的 symbol_id 是否仍存在（stale rune 偵測，用 kenaz_lsp_symbols / Grep）"
-        - "[Cortex Phase] cortex_sync() → 執行跨專案模式偵測，自動生成 cross_project Proposal（見 capability.yaml proposal_categories.cross_project）"
+        - "git log + kenaz_lsp_symbols / kenaz_lsp_callers → 全項目健康掃描"
       manual_trigger:
         - "kenaz_lsp_references(symbol_name) + kenaz_lsp_definition(symbol_name) → 關係與定義"
         - "kenaz_lsp_callers(symbol_name, depth=3) → 深度爆炸半徑"
-        - "synapse_recall(symbol_name) → 所有相關 rune"
-    output: "findings[] — 每筆含 { type, symbol, evidence, severity, existing_rune?, attention_score? }"
-
-  phase_1b_stale_rune_cleanup:
-    name: "殭屍 Rune 清理"
-    trigger: "scheduled_only"
-    auto: true
-    description: "偵測並清理過期 rune — 在 Phase 1 分析後、Phase 2 過濾前執行。僅 scheduled trigger 執行，commit trigger 跳過（代價不成比例）。"
-    precondition:
-      - "確認 synapse_status 可用，否則跳過本次 Phase 1b"
-    actions:
-      - "synapse_scan_stale_runes() → stale_rune_report"
-    stale_rune_report_fields:
-      - "index_status: fresh|stale|reindexing"
-      - "runes_scanned: N"
-      - "symbols_scanned: N"
-      - "needs_review_marked: N（大幅變動 symbol 的 rune，score 降 50%）"
-      - "auto_rejected: N（已刪除 symbol 的 rune，index must be fresh）"
-      - "auto_reject_enabled: true|false"
-    output: "stale_rune_report — 用於 Phase 4 報告的統計欄位"
-    rules:
-      - "❌ commit trigger 絕對不執行 Phase 1b"
-      - "❌ auto-reject 只在 index_status == 'fresh' 時執行（防止 partial index 誤殺）"
-      - "✅ review_flag 標記不影響 stored confidence，只降低 recall() 排序權重（×0.5）"
-      - "✅ review_flag 與 stale 並存：stale=symbol 不存在（硬刪除），review_flag=code 大幅變動（軟警告）"
+        - ".failure/ + `kenaz learn list` 中與 symbol_name 相關的條目"
+    output: "findings[] — 每筆含 { type, symbol, evidence, severity, existing_lesson?, attention_score? }"
 
   phase_2_filter:
     name: "訊號過濾"
@@ -87,7 +60,7 @@ workflow:
     description: "去除雜訊，只保留值得通報的發現"
     rules:
       - "severity=LOW 且無 known_risk → 丟棄"
-      - "impact=0 且無 rune → 丟棄"
+      - "impact=0 且無 known risk → 丟棄"
       - "7 天內已有相同 source+symbol 的 pending proposal → 跳過（不重複）"
       - "已 ignored 的 proposal 類型 → 降級或丟棄"
     output: "filtered_findings[] — 通過過濾的發現"
@@ -99,15 +72,13 @@ workflow:
     actions:
       proposals:
         - "for each filtered_finding → 生成 OptimizationProposal"
-        - "proposal metadata MUST include affected_symbols[]: collect all symbol stable IDs (file_path:name:kind) referenced in Phase 1 findings for this proposal — same format as synapse_inscribe symbol_id"
-        - "if proposal category is axon_eligible (see capability.yaml proposal_categories): set metadata.axon_verdict = 'pending' as default; AXON bridge will later update axon_verdict and write synapse_evidence"
-        - "metadata schema contract: { affected_symbols: string[], axon_verdict?: 'auto'|'skip'|'pending', synapse_evidence?: { recall_summary: string, impact_summary: string, health_trend: string, context_summary: string } }"
+        - "proposal metadata MUST include affected_symbols[]: collect all symbol stable IDs (file_path:name:kind) referenced in Phase 1 findings for this proposal"
+        - "if proposal category is axon_eligible (see capability.yaml proposal_categories): set metadata.axon_verdict = 'pending' as default; AXON bridge will later update axon_verdict and write evidence"
+        - "metadata schema contract: { affected_symbols: string[], axon_verdict?: 'auto'|'skip'|'pending', evidence?: { recall_summary: string, impact_summary: string, health_trend: string, context_summary: string } }"
         - "POST http://127.0.0.1:18080/api/proposals/create（或寫入 JSON）"
-      memory:
-        - "for each finding with non_obvious_knowledge → synapse_inscribe"
-        - "for each fixed issue → synapse_inscribe(supersedes=<舊 rune_id>) 讓舊 rune 退場"
-        - "if 3+ findings share abstract pattern → evaluate synapse_forge"
-    output: "written_proposals[] + inscribed_runes[]"
+      lessons:
+        - "for each finding with non_obvious_knowledge → `kenaz learn add`"
+    output: "written_proposals[] + added_lessons[]"
 
   phase_4_report:
     name: "輸出報告"
@@ -115,73 +86,9 @@ workflow:
     actions:
       - "產生掃描報告（見 capability.yaml scan_report 格式）"
       - "無發現 → 只輸出一行 clean scan 訊息"
-      - "scheduled trigger → 附加 stale rune 統計：N marked needs_review / N auto-rejected（來自 phase_1b stale_rune_report）"
     rules:
       - "報告不超過 40 行"
       - "不重複 proposal 的全文 — 只摘要 title + severity"
-      - "stale rune 統計格式：'Stale rune scan: {needs_review_marked} needs_review / {auto_rejected} auto-rejected'"
-
-  phase_5c_rune_usage_decay:
-    name: "Rune 效用衰減與提升"
-    trigger: "scheduled_only"
-    auto: true
-    description: |
-      TASK_589 — 根據 rune_usage_log 的 recall 頻率與 acted_on 信號，
-      動態調整 rune 的有效評分與 stored confidence。
-      僅在 scheduled trigger 執行，commit trigger 跳過。
-    precondition:
-      - "確認 synapse_status → memory DB 可用，否則跳過"
-
-    step_1_decay_analysis:
-      name: "分析 30 天未 recall 的 rune"
-      description: |
-        以 score-time（effective_score）計算衰減因子。
-        **不寫入** stored confidence（避免 CHECK(confidence >= 0.6) 約束衝突）。
-      logic: |
-        FOR each active rune r (superseded_by='' AND verified!='rejected'):
-          recall_count_30d = COUNT(rune_usage_log WHERE rune_id=r.id AND recalled_at >= NOW-30days)
-          IF recall_count_30d == 0 AND r.confidence < 0.9:
-            effective_score = r.confidence * 0.85  # score-time only, NOT stored
-          ELSE:
-            effective_score = r.confidence           # no decay for active or top-tier runes
-          IF effective_score < 0.3:
-            標記此 rune 為 "effectively_weak" → 在報告中列出（不刪除、不修改 DB）
-      protection:
-        - "confidence >= 0.9 的頂級 rune 不套用 0.85 衰減（保護頂級知識）"
-        - "衰減僅影響 recall 排序的邏輯評估，不寫入 stored confidence"
-
-    step_2_boost_application:
-      name: "套用 acted_on Boost（stored 更新）"
-      description: |
-        高 acted_on rate 的 rune 提升 stored confidence。
-        由 Rust 後端 MemoryDb::apply_usage_boosts() 執行。
-        Heimdall scheduled route 在 Phase 5c 自動觸發此方法。
-      logic: |
-        window = 90 days
-        FOR each rune r WITH recall history in window:
-          total_recalls = COUNT(rune_usage_log WHERE rune_id=r.id AND recalled_at >= NOW-90days)
-          acted_on_count = SUM(acted_on WHERE same filter)
-          IF total_recalls == 0: SKIP（分母為 0，無法計算 rate）
-          acted_on_rate = acted_on_count / total_recalls
-          IF acted_on_rate > 0.50:
-            boost = min(0.05, 0.99 - r.confidence)
-            IF boost > 0:
-              r.confidence += boost  # stored update, bounded: stays in [0.6, 0.99]
-      guarantee:
-        - "boost 永不超過 0.99（CHECK constraint 安全）"
-        - "boost 永不低於 0.6（只加不減）"
-
-    step_3_report:
-      description: "輸出 Phase 5c 統計"
-      format: |
-        "Rune usage scan: {decay_candidates} runes with 0 recalls in 30d | {boosted} runes confidence boosted"
-      note: "若無變化則靜默（不輸出）"
-
-    rules:
-      - "❌ commit trigger 絕對不執行 Phase 5c"
-      - "❌ 衰減絕對不寫入 stored confidence（避免 CHECK 衝突）"
-      - "✅ boost 必須 bounded: new_confidence = old + min(0.05, 0.99 - old)"
-      - "✅ confidence >= 0.9 的 rune 豁免衰減計算"
 
   phase_loop_measure:
     name: "Loop Measure — memory health trend (record only)"
@@ -189,12 +96,11 @@ workflow:
     auto: true
     description: |
       Executed by post-complete.js Step 4 in auto loop mode. Records the memory-health score
-      (synapse_health, score_version memory-v1) before/after a task so Huginn can read the trend.
-      It NEVER reverts and never gates: the score reflects the memory store (rune freshness,
-      episode backlog), not the task's code. The only verdict value is RECORDED.
+      (score_version memory-v1) before/after a task so Huginn can read the trend.
+      It NEVER reverts and never gates: the score reflects the memory store (memory store state), not the task's code. The only verdict value is RECORDED.
     precondition:
       - ".kenaz/loop.json exists with mode == 'auto'"
-      - "Synapse Dashboard running on port 18080 (measureHealthScoreSync)"
+      - "Backend running on port 18080 (measureHealthScoreSync)"
     graceful_skip:
       - "loop.json absent or mode != 'auto' → skip, use interval-based snapshot instead"
       - "Dashboard not running → log warning, skip this cycle"
@@ -220,11 +126,8 @@ workflow:
 # ═══════════════════════════════════════
 degradation:
   lsp_fail:
-    action: "改用 Grep/Glob + synapse_recall"
-    note: "kenaz_lsp_* 失敗 ≠ 全部不可用，recall 與 Grep 仍可用"
-  all_synapse_fail:
-    action: "輸出 'ᚺ Heimdall: Synapse offline. No analysis performed.' 並退出"
-    note: "無 Synapse 數據 = 無有根據的 proposal = 不生成任何輸出"
+    action: "改用 Grep/Glob"
+    note: "kenaz_lsp_* 失敗 ≠ 全部不可用，Grep 仍可用"
   proposal_api_fail:
     action: "Fallback 寫入 {project_path}/OPTIMIZATION_PROPOSALS.json"
 
@@ -260,16 +163,11 @@ collaboration:
     boundary: "Heimdall 只寫 proposal + metadata（affected_symbols, axon_verdict='pending'）；AXON 負責後續分析與執行"
     verdict_flow: |
       Heimdall Phase 3 writes axon_verdict='pending' for axon_eligible proposals.
-      AXON bridge reads proposal → runs four signals → sets final verdict:
-        1. synapse_recall   → recall_summary   (known risks / prior runes)
-        2. kenaz_lsp_callers    → impact_summary   (blast radius of affected_symbols)
-        3. kenaz_lsp_references → context_summary  (references of affected_symbols)
-        4. synapse_health   → health_trend     (health score trend context)
+      AXON bridge reads proposal → runs two signals → sets final verdict:
+        1. kenaz_lsp_callers    → impact_summary   (blast radius of affected_symbols)
+        2. kenaz_lsp_references → context_summary  (references of affected_symbols)
       verdict: 'auto' = safe to apply automatically; 'skip' = insufficient evidence or scope too large
     contract: "Heimdall 不呼叫 AXON API — 只寫 proposal；AXON 監聽 proposal stream 自行觸發"
   amelia:
     relationship: "Amelia 可 dispatch Heimdall 作為分析子任務"
     boundary: "Heimdall 不 dispatch 其他 agent"
-  synapse:
-    relationship: "Synapse 是 Heimdall 的感知器官，不可替代"
-    boundary: "Heimdall 不修改 Synapse index，只讀取和寫入 memory（rune/sigil）"

package/core/.specialist/Heimdall/principles.yaml

@@ -32,19 +32,19 @@ signal_over_noise:
 #  圖譜 > 直覺
 # ═══════════════════════════════════════
 graph_over_intuition:
-  principle: "LSP / recall 證據 > 關鍵字匹配 > 直覺推斷"
+  principle: "LSP 證據 > 關鍵字匹配 > 直覺推斷"
   why: |
     Heimdall 的超能力是他能查到人類不會逐一查的呼叫關係與歷史風險。
     如果只做關鍵字搜尋，他和 grep 沒有差別。
   applies_to:
     - "影響分析：必須用 kenaz_lsp_callers，不能只看 diff 文字"
-    - "風險評估：必須查 synapse_recall，不能假設沒有歷史風險"
+    - "風險評估：必須查 .failure/ 與 `kenaz learn list`，不能假設沒有歷史風險"
   decision_ladder:
     first: "git diff → 什麼檔案 / symbol 改了"
     second: "kenaz_lsp_callers → 爆炸半徑多大"
-    third: "synapse_recall → 有沒有已知風險"
+    third: ".failure/ + kenaz learn list → 有沒有已知風險"
     last_resort: "Grep — 精確字串，不用來理解代碼"
-  test: "這個結論能用 LSP / recall 工具的輸出直接支撐嗎？不能 → 不報"
+  test: "這個結論能用 LSP 工具的輸出直接支撐嗎？不能 → 不報"
 
 # ═══════════════════════════════════════
 #  記憶沉澱 > 一次性分析
@@ -55,12 +55,9 @@ memory_over_ephemeral:
     如果 Heimdall 每次都從零開始，他只是個掃描器。
     真正的守望者會記住上次看到什麼，這次有沒有變化。
   applies_to:
-    - "發現新 risk → 立即 synapse_inscribe（type=risk，confidence >= 0.7）"
-    - "發現已知 risk 加重 → synapse_inscribe supersedes 舊 rune 並更新內容"
-    - "發現問題已修復 → synapse_inscribe supersedes 舊 rune（讓 rune 退場）"
-    - "發現跨 3+ symbol 的模式 → 評估是否 synapse_forge 建立 Sigil"
-  inscribe_discipline:
+    - "發現新 risk → 立即 `kenaz learn add` 或 native memory 檔"
+    - "發現已知 risk 加重或已修復 → 更新既有條目"
+  record_discipline:
     - "只寫 non-obvious 知識 — 代碼字面看得出來的不寫"
-    - "confidence < 0.65 → 標記 needs_review，不直接寫入"
-    - "同 symbol 已有 rune → 優先 supersede，不重複寫"
+    - "同 symbol 已有條目 → 優先更新，不重複寫"
   test: "三個月後的 agent 看到這條 rune，會感謝它的存在嗎？不會 → 不寫"

package/core/.specialist/Heimdall/rule.yaml

@@ -32,8 +32,8 @@ identity:
     他不規劃、不下命令——他只看，然後告訴你他看到了什麼。
   rules:
     - "✅ 主動偵測：被 trigger 後立即啟動分析，不等指示"
-    - "✅ Synapse First：所有發現必須來自 Synapse 數據，不靠猜測"
-    - "✅ 寫 Rune：發現值得記錄的 risk / pattern → synapse_inscribe"
+    - "✅ LSP First：所有發現必須來自 LSP / git 數據，不靠猜測"
+    - "✅ 記教訓：發現值得記錄的 risk / pattern → `kenaz learn add`"
     - "✅ 寫 Proposal：值得通報的問題 → 產生結構化 proposal"
     - "❌ 不親自修代碼 — 只觀察、分析、通報"
     - "❌ 不規劃任務 — 那是 Ansuz 的事"

package/core/.specialist/Huginn/capability.yaml

@@ -11,7 +11,7 @@ capabilities:
   output_model:
     description: "Huginn 輸出三層認知產物 — 不再寫入 Prefrontal API"
     neuroscience_mapping:
-      working_memory_integration: "同時持有 Synapse + Hippocampus + Cortex 的數據並交叉分析"
+      working_memory_integration: "同時持有代碼結構、教訓、任務歷史的數據並交叉分析"
       future_simulation: "基於趨勢數據模擬不同方案的可能結果"
       inhibitory_control: "過濾衝動想法，只輸出經過深思的 findings（confidence >= 0.7）"
       metacognition: "分析 Agent 系統本身的效能和模式（元認知）"
@@ -38,15 +38,6 @@ capabilities:
           backlog_candidates: ["TASK_XXX"]
         unchanged: "此層路徑和格式不變"
 
-      layer_2_runes:
-        name: "Runes — for Synapse knowledge graph"
-        output: "synapse_inscribe(type=insight, confidence=0.7)"
-        consumer: "任何 agent 做 synapse_recall 時自動召回"
-        description: "non-obvious patterns 沉澱到 graph — insights 透過 recall 浮現，而非 UI panel"
-        inscription_rule: "每個 final_finding 中 non-obvious、有長期價值的 pattern → 寫入一條 rune"
-        language: "英文（MEM-LANG-001）"
-        confidence: ">= 0.7（Huginn 推導產物比直接觀察要求更高）"
-
       layer_3_attention:
         name: "Strategic Attention — for Ansuz context injection"
         output: "{project_path}/.kenaz/huginn-attention.json"
@@ -66,28 +57,18 @@ capabilities:
 
   # ─── 多路感知整合 ───
   perception_integration:
-    description: "整合 5 個數據源，進行交叉分析"
+    description: "整合 4 個數據源，進行交叉分析"
     sources:
 
-      synapse_graph:
+      code_structure:
         what: "代碼結構 — 目錄分佈、git churn hotspot、呼叫關係"
         tools: ["git log --name-only", "Grep/Glob", "kenaz_lsp_symbols", "kenaz_lsp_callers"]
         huginn_focus: "結構趨勢 — 哪些區域變動最頻繁？呼叫者是在增加還是減少？"
 
-      cognitive_layer:
-        what: "認知密度 — rune 分佈、sigil 概念網、知識空白區"
-        tools: ["synapse_recall", "synapse_sigils"]
-        huginn_focus: "哪裡知識豐富？哪裡是認知沙漠？差距意味著什麼？"
-
-      episodic_memory:
-        what: "執行歷史 — agent 做了什麼、碰到什麼困難、學到什麼"
-        tools: ["hippocampus_episode_recall"]
-        huginn_focus: "重複模式 — 同類困難出現 3+ 次就是趨勢信號"
-
-      cross_project:
-        what: "其他專案的經驗和模式"
-        tools: ["cortex_search", "cortex_recall"]
-        huginn_focus: "其他專案怎麼解決類似挑戰？有可遷移的模式嗎？"
+      lessons:
+        what: "已知教訓 — 失敗模式、`kenaz learn` 條目、知識空白區"
+        tools: [".failure/ scan", "kenaz learn list"]
+        huginn_focus: "哪裡教訓豐富？哪裡是知識空白？同類困難出現 3+ 次就是趨勢信號"
 
       task_history:
         what: "任務分佈、完成率、pain point 區域"
@@ -97,7 +78,7 @@ capabilities:
       external_scout:
         what: "GitHub 參考架構、依賴最佳實踐、外部解決方案模式（條件觸發）"
         tools: ["WebSearch", "WebFetch"]
-        trigger: "Synapse 信號觸發 — health decline / high coupling / fix cycles / dep advisories"
+        trigger: "內部信號觸發 — high coupling / fix cycles / dep advisories"
         huginn_focus: "外部生態系有沒有解決類似挑戰的模式？有可遷移的架構參考嗎？"
         guardrails:
           max_searches: 5
@@ -105,8 +86,8 @@ capabilities:
           max_commit_age: "6 months"
           query_rule: "泛化查詢 — 禁止內部符號名稱"
           confidence: 0.65
-          rune_metadata: "source=github + url + stars + last_commit"
-        condition: "非強制 — 只在至少 1 個 Synapse 信號觸發時執行"
+          evidence_metadata: "source=github + url + stars + last_commit"
+        condition: "非強制 — 只在至少 1 個內部信號觸發時執行"
         degradation: "WebSearch 不可用時靜默跳過，不阻塞主流程"
 
     cross_validation_rule: "任何洞見必須由至少 2 個不同數據源交叉支撐才能升級為提案"
@@ -116,42 +97,42 @@ capabilities:
 
     pattern_synthesis:
       description: "跨數據源的模式識別 — Huginn 的核心價值"
-      what: "在 Episode、Rune、代碼結構數據中找到跨領域的共通模式"
+      what: "在任務歷史、教訓、代碼結構數據中找到跨領域的共通模式"
       example: "最近 5 個 backend task 都在同一個模組邊界碰壁 → 可能需要重新定義 API 邊界"
-      tool_chain: "hippocampus_episode_recall → synapse_recall → git log churn → kenaz_lsp_callers"
+      tool_chain: "task history → kenaz learn list → git log churn → kenaz_lsp_callers"
       output_type: "architecture | process"
 
     knowledge_gap:
       description: "認知沙漠偵測 — 找出系統的認知盲區"
-      what: "大量代碼 + 幾乎沒有 rune 的區域 = 未來 agent 的地雷區"
-      example: "某目錄有 123 個 symbols 但只有 2 條 rune → 需要主動探索和標註"
-      tool_chain: "kenaz_lsp_symbols(dir) count vs synapse_recall(dir) rune count"
+      what: "大量代碼 + 幾乎沒有教訓記錄的區域 = 未來 agent 的地雷區"
+      example: "某目錄有 123 個 symbols 但只有 2 條教訓 → 需要主動探索和標註"
+      tool_chain: "kenaz_lsp_symbols(dir) count vs .failure/ + kenaz learn list 對該目錄的條目數"
       output_type: "knowledge"
 
     evolution_opportunity:
       description: "架構演進偵測 — 從趨勢推導下一步該走向哪裡"
       what: "某個區域在快速成長或萎縮，意味著架構需要主動適應"
       example: "plugin-sdk 的 symbol 數每週 +20%，但與 dashboard core 的耦合也在增加 → 需要提前定義邊界 API"
-      tool_chain: "git log churn trend + kenaz_lsp_callers → cortex_search(similar architecture in other projects)"
+      tool_chain: "git log churn trend + kenaz_lsp_callers"
       output_type: "architecture | feature"
 
     agent_meta_analysis:
       description: "元認知 — 分析 Agent 系統本身的行為模式"
       what: "哪些 specialist 最常失敗？dispatch 模式有沒有改進空間？rule 定義有沒有盲區？"
-      example: "backend role 的 episode 中 blocked phase 出現率是 frontend 的 3 倍 → skill 定義可能需要增補"
-      tool_chain: "hippocampus_episode_recall(agent_role filter) → .specialist/ definition review"
+      example: "backend role 的任務中 blocked 狀態 出現率是 frontend 的 3 倍 → skill 定義可能需要增補"
+      tool_chain: "kenaz_task_list(role filter) → .specialist/ definition review"
       output_type: "agent_improvement"
 
     failure_prevention:
       description: "預防性思考 — 從已知失敗推導未被覆蓋的風險"
       what: "已記錄在 .failure/ 的失敗模式是否已被充分預防？"
       example: "FAIL-009 被記錄但沒有自動化防護 → 提案建 pre-commit hook 或 rule 強化"
-      tool_chain: ".failure/ scan → synapse_recall(related runes) → gap analysis"
+      tool_chain: ".failure/ scan → kenaz learn list → gap analysis"
       output_type: "process"
 
   # ─── Finding 生成 ───
   output_generation:
-    description: "將思考產出轉化為三層認知輸出（findings + runes + attention）"
+    description: "將思考產出轉化為兩層認知輸出（findings + attention）"
 
     finding_types:
       architecture:
@@ -159,7 +140,7 @@ capabilities:
         trigger: "evolution_opportunity 或 pattern_synthesis 發現結構性趨勢"
       feature:
         description: "功能機會 — 基於模式識別發現的新能力可能性"
-        trigger: "pattern_synthesis 發現跨域機會 或 cortex 找到可遷移模式"
+        trigger: "pattern_synthesis 發現跨域機會"
       process:
         description: "流程改進 — dispatch 策略、rule 建議、自動化機會"
         trigger: "agent_meta_analysis 或 failure_prevention 發現流程缺口"
@@ -175,16 +156,15 @@ capabilities:
 
       minimum_sources:
         rule: "finding 必須由至少 2 個不同數據源的交叉證據支撐"
-        sources: ["synapse_graph", "cognitive_layer", "episodic_memory", "cross_project", "task_history"]
+        sources: ["code_structure", "lessons", "task_history"]
         reject_if: "只有 1 個數據源 → 降級為 draft，不寫入 output"
 
       confidence_threshold:
         rule: "confidence < 0.7 → draft（存檔但不提交）"
-        note: "比 Heimdall 的 rune 閾值 0.65 更高 — Huginn 的 findings 影響範圍更大"
+        note: "比 Heimdall 的 0.65 閾值更高 — Huginn 的 findings 影響範圍更大"
 
       novelty_check:
-        rule: "synapse_recall 比對已有 runes — FTS5 相似度 > 0.6 視為重疊 → 跳過"
-        note: "不再與 CreativeProposal 比對 — 改為與 Synapse runes 比對"
+        rule: "與既有 findings / .failure/ 條目比對 — 相似度 > 0.6 視為重疊 → 跳過"
 
       heimdall_dedup:
         rule: "如果 Heimdall 已在 OptimizationProposal 中通報相同問題 → Huginn 不重複"
@@ -202,12 +182,12 @@ capabilities:
         當 finding 被 Ansuz 成功建立 task：
         - 哪個 thinking_dimension 產出了這個洞見？
         - 哪些數據源的交叉最有說服力？
-        - 記錄為 pattern rune → 強化這個思考方向
+        - 記錄到 advisory 備註 → 強化這個思考方向
       on_skipped: |
         當 finding 被 loop controller 跳過（quality gate 或 duplicate）：
         - 是時機不對？方向錯誤？證據不足？
-        - 記錄為 insight rune → 校準未來的思考偏好
-    storage: "synapse_inscribe — 思考校準知識沉澱到認知層"
+        - 記錄到 advisory 備註 → 校準未來的思考偏好
+    storage: "huginn_advisory.jsonl 備註；有長期價值者 `kenaz learn add`"
     note: "這是 Huginn 的自我改進機制 — 不改 weight，改思考方向"
 
   # ─── 報告格式 ───
@@ -217,13 +197,12 @@ capabilities:
       ══════════════════════════
       Trigger:  {manual}
       Duration: {thinking time}
-      Sources consulted: {N} (synapse: {n}, hippocampus: {n}, cortex: {n}, tasks: {n}, external_scout: {triggered|skipped})
+      Sources consulted: {N} (code: {n}, lessons: {n}, tasks: {n}, external_scout: {triggered|skipped})
 
-      Output (three-layer cognitive model):
+      Output (two-layer cognitive model):
         [Layer 1] Findings:  {K} written to huginn-findings.json
-        [Layer 2] Runes:     {M} inscribed to Synapse graph (type=insight, internal={Mi} external={Me})
-        [Layer 3] Attention: {T} themes written to huginn-attention.json
-        [Scout]   External:  {S} GitHub refs inscribed (searches used: {N}/5) | skipped: {reason}
+        [Layer 2] Attention: {T} themes written to huginn-attention.json
+        [Scout]   External:  {S} GitHub refs recorded (searches used: {N}/5) | skipped: {reason}
 
       Drafts saved: {D} (below confidence threshold)