kenaz 0.3.10 → 0.3.12

package/core/.specialist/Ansuz/knowledge.yaml

@@ -149,13 +149,11 @@ agent_types:
 # ═══════════════════════════════════════
 # §synapse
 synapse:
-  overview: "Rust-native 記憶系統 — SQLite FTS5（全文）+ ONNX（語義嵌入）；代碼導航改用 kenaz_lsp_* 與 Grep/Glob"
-  data_path: "<project>/.synapse/db/"
+  overview: "代碼導航用 kenaz_lsp_* 與 Grep/Glob（記憶系統 synapse_*/cortex_* 已於 TASK_2411 移除；教訓用 `kenaz learn add` 或 native memory 檔）"
 
   # ─── Ansuz 各 Phase 的 Synapse 應用 ───
   phase_usage:
-    phase_0_init: "synapse_status → 確認可用性"
-    phase_2_research: "Grep/Glob → 搜尋相關代碼；kenaz_lsp_callers → 理解調用鏈；synapse_recall → 歷史 rune"
+    phase_2_research: "Grep/Glob → 搜尋相關代碼；kenaz_lsp_callers → 理解調用鏈"
     phase_3_task_design: "kenaz_lsp_callers / kenaz_lsp_references → 確認 scope_paths 涵蓋所有受影響的 symbol"
     phase_9_verify: "git diff --stat → 確認改動範圍；kenaz_lsp_callers → 驗證無 regression"
 
@@ -165,49 +163,25 @@ synapse:
     - "「誰呼叫它？」「改了會影響哪裡？」→ kenaz_lsp_callers / kenaz_lsp_references"
     - "「它定義在哪？」→ kenaz_lsp_definition"
     - "「最近改了什麼？」→ git diff / git log"
-    - "「歷史知識？」→ synapse_recall"
-    - "精確字串/正則匹配 → Grep（不用 Synapse）"
+    - "「歷史知識？」→ native memory 檔 / `kenaz learn list`"
+    - "精確字串/正則匹配 → Grep"
 
-  fallback: "首次 Synapse 呼叫失敗 → 該 session 全程降級 Grep/Glob，不重試不阻塞"
+  fallback: "首次 kenaz_lsp_* 呼叫失敗 → 該 session 全程降級 Grep/Glob，不重試不阻塞"
 
 # ═══════════════════════════════════════
-#  Cortex 跨專案智能系統
+#  代碼導航工具使用指引（dispatch 用）
 # ═══════════════════════════════════════
-# §cortex
-cortex:
-  overview: "跨專案知識圖譜 — Global Memory（SQLite FTS5）"
-  data_path:
-    global_memory: "~/.kenaz/cortex/global_memory.db"
-
-  # ─── Ansuz 各 Phase 的 Cortex 應用 ───
-  phase_usage:
-    phase_0_init: "cortex_status → 跟 synapse_status 一起偵測跨專案數據可用性"
-    phase_2_research: "cortex_recall → 查跨專案歷史知識；cortex_search → 找其他專案的參考實現"
-    phase_3_task_design: "cortex_recall → 判斷是否有可複用的跨專案實現；cortex_search → 架構決策參考"
-    phase_9_verify: "cortex_recall → 驗證修復方案是否與其他專案的歷史經驗一致"
-
-  # ─── 選擇指南 ───
-  decision_guide:
-    - "「其他專案怎麼處理這個問題？」→ cortex_search(exclude_current=true)"
-    - "「這個概念在哪些專案出現？跨專案有什麼歷史經驗？」→ cortex_recall"
-    - "「單一專案的符號關係？」→ kenaz_lsp_callers / kenaz_lsp_references"
-    - "當前專案內搜尋 → 用 Synapse，不用 Cortex"
-    # cortex_relate / cortex_overview / cortex_cypher 已隨 meta_graph 退役（TASK_2048 移除，TASK_2051 清理）
-
-# ═══════════════════════════════════════
-#  Synapse 工具使用指引（dispatch 用）
-# ═══════════════════════════════════════
-# 目的：確保 Ansuz dispatch 的 sub-agent 知道 Synapse-first 原則
+# 目的：確保 Ansuz dispatch 的 sub-agent 知道 LSP/Grep 導航原則
 # 此 section 精簡摘要 .rule/general/synapse-code-intelligence.yaml (SYN-001~007)
 # 的關鍵決策點，不重複全文
 # §synapse_tools
 synapse_tools:
-  principle: "Synapse First — 理解代碼時優先用 Synapse，Grep 僅用於精確字串/正則/枚舉"
+  principle: "理解代碼時優先用 kenaz_lsp_*，Grep 用於精確字串/正則/枚舉"
 
   # ─── projectPath 強制規則（全局，非僅子專案） ───
   project_path:
     rule: |
-      ⚠️ 所有 Synapse / Cortex MCP 呼叫必須帶 projectPath 參數。
+      ⚠️ 所有 kenaz_lsp_* MCP 呼叫必須帶 projectPath 參數。
       Dashboard active project 可能指向其他專案，default project 不可靠。
       Phase 0 確認 projectPath 後，後續每次呼叫都帶上。
     resolve: |
@@ -222,10 +196,9 @@ synapse_tools:
     call_chain: "kenaz_lsp_callers(symbol, depth) — 「誰呼叫了它？」"
     blast_radius: "kenaz_lsp_references(symbol) — 「改了會影響哪裡？」"
     recent_changes: "git diff / git log — 「最近改了什麼？」"
-    history_knowledge: "synapse_recall — 查詢歷史 rune/sigil 認知知識"
-    cross_project: "cortex_search / cortex_recall — 跨專案搜尋（見 cortex section）"
-    exact_string: "Grep — 精確字串/正則匹配（不用 Synapse）"
-    file_path: "Glob/Read — 已知文件名或路徑（不用 Synapse）"
+    history_knowledge: "native memory 檔 / `kenaz learn list`"
+    exact_string: "Grep — 精確字串/正則匹配"
+    file_path: "Glob/Read — 已知文件名或路徑"
 
   # ─── Fallback ───
   fallback_cascade:
@@ -243,7 +216,7 @@ synapse_tools:
   # ─── 子專案場景（projectPath 的特殊情況） ───
   sub_project:
     description: |
-      子專案的 Synapse 索引獨立於 Core。projectPath 解析見上方 project_path.resolve。
+      子專案的 LSP 索引獨立於 Core。projectPath 解析見上方 project_path.resolve。
     note: "projectPath 是全局強制規則（見 project_path section），子專案只是路徑來源不同"
 
   # ─── 禁止行為（速記） ───

package/core/.specialist/Ansuz/modules/ddx.yaml

@@ -39,8 +39,8 @@ prophecy_handoff:
   rule: |
     DDx 識別出 2+ 方案後，不可直接靠推斷選方案。
     必須接入預言比較（prophecy.yaml）：
-    - Phase 2 已有 callers/recall 結果 → 直接引用數據
-    - Phase 2 無 callers/recall 結果 → 補跑：對每個方案目標 symbol 各跑 kenaz_lsp_callers + synapse_recall
+    - Phase 2 已有 callers 結果 → 直接引用數據
+    - Phase 2 無 callers 結果 → 補跑：對每個方案目標 symbol 各跑 kenaz_lsp_callers + kenaz_lsp_references
   decision_flow: |
     DDx 列出方案 → 預言比較量化風險 → 結構數據選方案 → 任務設計用選中方案的 scope
     (鑑別回答「有哪些選擇」→ 預言回答「選哪個」)

package/core/.specialist/Ansuz/modules/prophecy.yaml

@@ -1,5 +1,5 @@
 name: Prophecy Module — Prophetic Comparison Protocol
-description: "多方案時，對每個方案的目標 symbol 各跑 kenaz_lsp_callers + synapse_recall，用結構數據選方案 — 不靠直覺"
+description: "多方案時，對每個方案的目標 symbol 各跑 kenaz_lsp_callers + kenaz_lsp_references，用結構數據選方案 — 不靠直覺"
 source: "capability.yaml prophetic_comparison (L129-179) + workflow.yaml Phase 2/3 (L308-374)"
 
 # ═══════════════════════════════════════
@@ -17,12 +17,12 @@ when:
 phase_2_trigger: |
   Phase 2 調研過程中偵測到以下任一信號：
   - 需求描述包含選擇（「A 或 B」「可以改 X 也可以改 Y」）
-  - recall/callers 結果顯示多個可行切入點（如 callers 分佈在不同模組）
+  - callers 結果顯示多個可行切入點（如 callers 分佈在不同模組）
   - DDx 產出 2+ 競爭方案（詳見 ddx.yaml）
   - Ansuz 自身分析出 2+ 路徑
 phase_2_actions:
-  - "對每個方案的目標 symbol 各跑 kenaz_lsp_callers + synapse_recall（可並行）"
-  - "收集 caller 數 / 跨模組數 / known_risks"
+  - "對每個方案的目標 symbol 各跑 kenaz_lsp_callers + kenaz_lsp_references（可並行）"
+  - "收集 caller 數 / 跨模組數 / .failure 風險"
   - "填入 🔮 預言比較 cli_format 表格"
   - "比較結果直接注入 Phase 3 的 scope_paths 和 complexity 決策"
 phase_2_fallback: "kenaz_lsp_callers 不可用 → 用 Grep 找 symbol 引用數替代"
@@ -33,13 +33,13 @@ phase_2_fallback: "kenaz_lsp_callers 不可用 → 用 Grep 找 symbol 引用數
 phase_3_integration:
   rule: |
     DDx 識別出 2+ 方案後，必須檢查 Phase 2 是否已有預言比較結果：
-    - 有 → 直接引用 callers/recall 數據做選擇
-    - 無 → 此刻補跑：對每個方案目標 symbol 各跑 kenaz_lsp_callers + synapse_recall，填入比較表格
+    - 有 → 直接引用 callers 數據做選擇
+    - 無 → 此刻補跑：對每個方案目標 symbol 各跑 kenaz_lsp_callers + kenaz_lsp_references，填入比較表格
   scope_derivation: |
-    選中方案的 callers + recall 結果直接決定：
-    - scope_paths ← callers/references 涉及的文件路徑（HIGH-risk rune 所在檔案優先）
+    選中方案的 callers 結果直接決定：
+    - scope_paths ← callers/references 涉及的文件路徑
     - complexity ← caller 數 + 跨模組數
-    - technical_notes ← recall 的 known_risks + 被排除方案的理由（「為什麼不選 B」）
+    - technical_notes ← .failure 風險 + 被排除方案的理由（「為什麼不選 B」）
 
 # ═══════════════════════════════════════
 #  Protocol
@@ -48,20 +48,20 @@ protocol:
   step_1_detect: |
     偵測多方案情境（任何以下信號）：
     - Phase 1 需求本身包含「或」「還是」等選擇詞
-    - Phase 2 recall/callers 結果顯示多個可行切入點
+    - Phase 2 callers 結果顯示多個可行切入點
     - DDx 識別出 2+ 競爭方案
     - Ansuz 自身分析出 2+ 路徑
   step_2_impact: |
     對每個方案的核心 symbol 各查一次影響範圍：
-    - 方案 A → kenaz_lsp_callers(symbolA) + synapse_recall(symbolA) → 取得 callers 數與已知 rune
-    - 方案 B → kenaz_lsp_callers(symbolB) + synapse_recall(symbolB) → 同上
+    - 方案 A → kenaz_lsp_callers(symbolA) + kenaz_lsp_references(symbolA) → 取得 callers / references 數
+    - 方案 B → kenaz_lsp_callers(symbolB) + kenaz_lsp_references(symbolB) → 同上
     - 可並行呼叫（無依賴）
     - kenaz_lsp_callers 不可用時 fallback: Grep 引用數 symbolA vs symbolB
   step_3_compare: |
     結構化對比五個維度：
     1. caller 數 — 爆炸半徑（越小越安全）
     2. 跨模組數 — callers 分佈的模組數（越少越乾淨）
-    3. known_risks — 歷史 rune 風險數（越少越安心）
+    3. .failure 風險 — 已知風險數（越少越安心）
     4. 風險等級（LOW > MEDIUM > HIGH，由前三項綜合）
   step_4_decide: |
     選擇邏輯：
@@ -72,17 +72,17 @@ protocol:
 rules:
   - "✅ 靈活觸發 — 不限於 Phase 2/3，任何階段偵測到多方案就啟動"
   - "✅ 最少 2 個方案，最多 5 個（超過先用 DDx 粗篩再比較）"
-  - "✅ callers/recall 結果直接驅動 Phase 3 的 scope_paths 和 complexity"
+  - "✅ callers 結果直接驅動 Phase 3 的 scope_paths 和 complexity"
   - "❌ 禁止只查一個方案就決定 — 至少 2 個對照"
-  - "❌ 禁止推斷式比較 — 「我覺得 A 比 B 簡單」不算，必須有 callers/recall 數據"
+  - "❌ 禁止推斷式比較 — 「我覺得 A 比 B 簡單」不算，必須有 callers 數據"
 
 cli_format: |
   🔮 預言比較
   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   | 方案 | 目標 Symbol | 爆炸半徑 | 跨模組 | 歷史風險 | 風險等級 |
   |------|------------|---------|--------|---------|---------|
-  | A | {symbol} | {N} | {N} | {N} runes | {level} |
-  | B | {symbol} | {N} | {N} | {N} runes | {level} |
+  | A | {symbol} | {N} | {N} | {N} risks | {level} |
+  | B | {symbol} | {N} | {N} | {N} risks | {level} |
 
   結論: 方案 {X} — {一句話理由}
   {如 trade-off 明顯 → 列出讓用戶決定}
@@ -90,6 +90,6 @@ cli_format: |
 
 example: |
   需求：「修復 data flow 斷裂，可以改 source 端或改 sink 端」
-  → callers+recall(source_symbol) → 8 callers, 跨 1 模組, 0 risks
-  → callers+recall(sink_symbol)   → 22 callers, 跨 3 模組, 2 risks
+  → callers(source_symbol) → 8 callers, 跨 1 模組, 0 risks
+  → callers(sink_symbol)   → 22 callers, 跨 3 模組, 2 risks
   → 結論: 改 source 端 — 爆炸半徑小 3 倍，零歷史風險

package/core/.specialist/Ansuz/modules/pulse_empty.yaml

@@ -1,20 +1,18 @@
 name: Pulse Empty Protocol
-description: "synapse_recall 與 kenaz_lsp_callers 回空時的替代策略 — 新功能/新專案/未知領域"
-source: "workflow.yaml Phase 2 pulse_empty_protocol (L289-307)"
+description: "kenaz_lsp_callers 回空時的替代策略 — 新功能/新專案/未知領域"
+source: "workflow.yaml Phase 2 empty_result_protocol"
 
 # ═══════════════════════════════════════
 #  觸發條件
 # ═══════════════════════════════════════
 trigger:
-  when: "synapse_recall 無 rune 且 kenaz_lsp_callers 無呼叫者（新功能、新專案、未知領域）"
-  principle: "本地無資料 → 跨神經網路查詢（Cortex）→ 手動探索 → 保守設計"
+  when: "kenaz_lsp_callers 無呼叫者（新功能、新專案、未知領域）"
+  principle: "本地無資料 → 手動探索 → 保守設計"
 
 # ═══════════════════════════════════════
 #  Phase 2 替代行動
 # ═══════════════════════════════════════
 phase_2_actions:
-  - "cortex_search({ query: '<功能描述>' }) — 跨專案語義搜尋：其他專案有沒有類似功能的實現？"
-  - "cortex_recall({ query: '<領域關鍵詞>' }) — 跨專案認知回憶：其他專案在同領域踩過什麼坑？有什麼架構決策？這個概念在哪些專案出現過？"
   - "Grep/Read — 手動探索相關目錄結構和現有 pattern"
   - "查 .failure/ — 類似功能有沒有已知失敗模式"
 
@@ -22,15 +20,6 @@ phase_2_actions:
 #  Phase 3 設計補充
 # ═══════════════════════════════════════
 phase_3_actions:
-  - "scope_paths 靠目錄結構 + 現有 pattern + Cortex 建議推斷（標記為 '未經 LSP 驗證'）"
+  - "scope_paths 靠目錄結構 + 現有 pattern 推斷（標記為 '未經 LSP 驗證'）"
   - "complexity 預設 medium（無數據，保守估計）"
-  - "technical_notes 必須注入：'此任務為新功能/未知領域，無本地 recall/callers 數據。Cortex 跨專案參考：{cortex 結果摘要}。Agent 需自行探索 codebase 並遵循現有 pattern。'"
-  - "如果 Cortex 找到其他專案的類似實現 → 在 technical_notes 中附上參考路徑和 pattern"
-
-# ═══════════════════════════════════════
-#  完成後的認知種子（特別重要）
-# ═══════════════════════════════════════
-post_code_emphasis:
-  - "synapse_inscribe — 為新功能留下認知種子（這是該領域的第一顆種子）"
-  - "synapse_forge — 如果新功能涉及 3+ symbols → 建立 Sigil 概念節點"
-  - "這些種子是未來 agent 在這個領域的起點 — 寧可多寫不可少寫"
+  - "technical_notes 必須注入：'此任務為新功能/未知領域，無本地 callers 數據。Agent 需自行探索 codebase 並遵循現有 pattern。'"

package/core/.specialist/Ansuz/tools/ansuz-handoff-snapshot.js

@@ -289,103 +289,6 @@ function atomicWriteJson(filePath, obj) {
   }
 }
 
-// ─────────────────────────────────────────
-// Dashboard HTTP helpers (best-effort — skip gracefully if server not running)
-// ─────────────────────────────────────────
-
-async function callMcpTool(toolName, toolArgs) {
-  const http = require('http');
-  const body = JSON.stringify({
-    jsonrpc: '2.0',
-    id: 1,
-    method: 'tools/call',
-    params: { name: toolName, arguments: toolArgs },
-  });
-
-  return new Promise((resolve, reject) => {
-    const req = http.request(
-      {
-        hostname: '127.0.0.1',
-        port: 18080,
-        path: '/api/mcp',
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Content-Length': Buffer.byteLength(body),
-        },
-        timeout: 4000,
-      },
-      (res) => {
-        let data = '';
-        res.on('data', (chunk) => { data += chunk; });
-        res.on('end', () => {
-          try {
-            const parsed = JSON.parse(data);
-            if (parsed.error) { reject(new Error(parsed.error.message)); return; }
-            const text = parsed.result?.content?.[0]?.text;
-            resolve(text ? JSON.parse(text) : parsed.result);
-          } catch (e) { reject(e); }
-        });
-      }
-    );
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('mcp timeout')); });
-    req.write(body);
-    req.end();
-  });
-}
-
-async function getKeyDecisionsFromSynapse(projectPath, n = 5) {
-  try {
-    // Use synapse_recall (project-scoped, honours projectPath) — NOT cortex_recall,
-    // which is cross-project global and would bleed core/other-project decisions
-    // into a sub-project's handoff (e.g. KenazAI HOOK_MARKER/TASK_574 into jiayao).
-    const result = await callMcpTool('synapse_recall', {
-      query: 'decision risk ash',
-      type: 'decision',
-      projectPath,
-      limit: n,
-    });
-    const runes = result?.runes || [];
-    if (!Array.isArray(runes) || runes.length === 0) return null;
-    return runes.slice(0, n).map((r) => {
-      const type = r.type || r.rune_type || 'rune';
-      const text = r.content || r.body || r.summary || '';
-      return `[${type}] ${String(text).substring(0, 100)}`;
-    }).filter(Boolean);
-  } catch {
-    return null;
-  }
-}
-
-async function archiveHandoffToHippocampus(handoff, projectPath) {
-  try {
-    const startResult = await callMcpTool('hippocampus_episode_start', {
-      scope: `handoff:${handoff.session_id}`,
-      projectPath,
-    });
-    const episodeId = startResult?.episode_id;
-    if (!episodeId) return false;
-
-    await callMcpTool('hippocampus_episode_append', {
-      episode_id: episodeId,
-      phase: 'archive',
-      content: JSON.stringify(handoff, null, 2),
-      projectPath,
-    });
-
-    await callMcpTool('hippocampus_episode_close', {
-      episode_id: episodeId,
-      summary: `Archived handoff snapshot session=${handoff.session_id} trigger=${handoff.triggered_by}`,
-      outcome: 'archived',
-      projectPath,
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 // ─────────────────────────────────────────
 // ISBAR builder
 // ─────────────────────────────────────────
@@ -560,17 +463,15 @@ async function main() {
   if (fs.existsSync(handoffPath)) {
     try {
       const existing = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
-      if (existing.session_id && existing.session_id !== sessionId) {
-        await archiveHandoffToHippocampus(existing, projectPath);
-      } else if (existing.session_id === sessionId) {
+      if (existing.session_id === sessionId) {
         priorHistory = Array.isArray(existing.history) ? existing.history.slice(-9) : [];
         if (existing.generated_at) priorHistory.push(existing.generated_at);
       }
     } catch { /* ignore corrupt/missing */ }
   }
 
-  // Pull recent decision/risk runes from this project's Synapse (best-effort; skip if dashboard not running)
-  const keyDecisions = await getKeyDecisionsFromSynapse(projectPath, 5);
+  // Key decisions came from Synapse runes; the memory system was removed in TASK_2411.
+  const keyDecisions = null;
 
   // Build handoff object
   const generatedAt = new Date().toISOString();

package/core/.specialist/Ansuz/tools/ansuz-sdk-runner.js

@@ -838,37 +838,6 @@ async function runBackgroundCognitiveLoop(lastActivityMs = Date.now()) {
   try {
     const signalsToAppend = [];
 
-    // Step 4c: hippocampus_due_episodes as signal source (TASK_965)
-    try {
-      const dueResp = await callMcpTool('hippocampus_due_episodes', { projectPath: ROOT }, MCP_FAST_TIMEOUT_MS);
-      const dueContent = dueResp?.result?.content || dueResp?.content || [];
-      const dueText = (Array.isArray(dueContent) ? dueContent : [dueContent])
-        .map(c => (typeof c === 'string' ? c : c?.text || '')).join('\n');
-      let dueCount = 0;
-      try {
-        const parsed = JSON.parse(dueText);
-        dueCount = parsed?.due_count ?? (Array.isArray(parsed?.episodes) ? parsed.episodes.length : 0);
-      } catch { /* non-JSON */ }
-      if (dueCount > 0) {
-        signalsToAppend.push({
-          detected_at: new Date().toISOString(),
-          source: 'hippocampus',
-          signal_type: 'due_episodes',
-          summary: `${dueCount} hippocampus episode(s) due for review`,
-          symbols: ['hippocampus_review'],
-          meta: { due_count: dueCount },
-        });
-        log(`[BG] Signal: due_episodes — ${dueCount} episode(s) due`);
-      } else {
-        // TASK_1095 (I1): source cleared — drop stale ambient entries AND
-        // evict hippocampus_review from attentionBuffer so Grade 4 routing
-        // stops re-appending on subsequent cycles.
-        reconcileSignalSource('due_episodes', false, ['hippocampus_review']);
-      }
-    } catch (e) {
-      log(`[BG] Warning: hippocampus_due_episodes failed (5s timeout): ${e.message}`);
-    }
-
     // TASK_1095 (Amelia Blocker 4): TTL-based defense in depth for signal types
     // with no MCP source-check (curiosity_spike, hot_symbol_unaddressed_risk,
     // efe_weight_shift, heat). 30min > 5min tick interval but < 50min trim horizon.
@@ -953,9 +922,8 @@ function buildThalamusPrompt(msg) {
     `Suggested action: ${ctx.suggested_action || 'update stale runes'}`,
     ``,
     `## Allowed Actions (Level 1 only)`,
-    `- Update stale runes for fired symbols (synapse_recall → synapse_inscribe if outdated)`,
+    `- Review the fired symbols with kenaz_lsp_references / kenaz_lsp_callers`,
     `- Fix lint issues in fired symbol files`,
-    `- Inscribe new risk/fix runes for discovered issues`,
     ``,
     `## Forbidden Actions`,
     `- Do NOT create new tasks`,
@@ -964,7 +932,7 @@ function buildThalamusPrompt(msg) {
     `- Do NOT create pull requests`,
     `- Do NOT modify files outside the fired symbols' scope`,
     ``,
-    `Review fired symbols, update any stale runes, and report findings. Keep it brief.`,
+    `Review the fired symbols and report findings. Keep it brief.`,
   ].join('\n');
 }
 
@@ -999,25 +967,15 @@ async function runQuery(prompt, sessionId) {
       'Bash', 'Edit', 'Glob', 'Grep', 'Read', 'Write',
       'ToolSearch', 'TodoWrite', 'WebFetch', 'WebSearch',
       'AskUserQuestion',
-      'mcp__kenaz-dashboard__synapse_recall',
       'mcp__kenaz-dashboard__kenaz_lsp_callers',
       'mcp__kenaz-dashboard__kenaz_lsp_references',
       'mcp__kenaz-dashboard__kenaz_lsp_definition',
       'mcp__kenaz-dashboard__kenaz_lsp_symbols',
-      'mcp__kenaz-dashboard__synapse_inscribe',
-      'mcp__kenaz-dashboard__synapse_forge',
-      'mcp__kenaz-dashboard__synapse_sigils',
-      'mcp__kenaz-dashboard__hippocampus_episode_start',
-      'mcp__kenaz-dashboard__hippocampus_episode_append',
-      'mcp__kenaz-dashboard__hippocampus_episode_close',
-      'mcp__kenaz-dashboard__hippocampus_episode_recall',
-      'mcp__kenaz-dashboard__hippocampus_episode_link',
       'mcp__kenaz-dashboard__kenaz_task_create',
       'mcp__kenaz-dashboard__kenaz_task_update',
       'mcp__kenaz-dashboard__kenaz_task_list',
       'mcp__kenaz-dashboard__kenaz_task_get',
       'mcp__kenaz-dashboard__kenaz_task_delete',
-      'mcp__kenaz-dashboard__cortex_recall',
     ],
     mcpServers: {
       'kenaz-dashboard': {