kenaz 0.3.9 → 0.3.11

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': {

package/core/.specialist/Ansuz/workflow.yaml

@@ -136,8 +136,6 @@ phase_0_initialization:
     - "node {CORE}/.collaboration/core/task-api.js [--project-path {PROJECT_PATH}] list — 統計任務狀態"
     - "node {CORE}/.collaboration/core/task-api.js [--project-path {PROJECT_PATH}] stats — 取得統計數據"
     - "讀 .failure/INDEX.yaml — 檢查已知失敗模式（從 CORE 讀取）"
-    - "synapse_status — 檢查索引狀態。注意 rune_count/sigil_count：這些是其他 agent 留下的認知記憶，裡面有 bug 根因、設計決策、隱藏約束等你看不到的知識。數字越大，認知層越豐富 — 後續工作中遇到相關 symbol 時用 synapse_recall 查詢"
-    - "cortex_status — 檢查跨專案數據可用性（失敗則跳過 Cortex，不阻塞）"
   present:
     banner: "ᚨ Ansuz 已就位"
     show:
@@ -192,12 +190,7 @@ phase_0_initialization:
 phase_1_requirement_analysis:
   goal: "快速理解用戶需求，澄清模糊點"
   cognitive_checkpoint:
-    recall: "synapse_recall + cortex_recall 並行查詢需求相關的歷史 rune（risk/fix），帶著認知做分析"
-    rule: "Phase 1 開始時必須執行 recall（本地 + 跨專案），不可跳過"
-    parallel: |
-      同時呼叫（無依賴，必須並行）：
-      - synapse_recall({ query: '<需求關鍵詞>' }) — 本地認知
-      - cortex_recall({ query: '<需求關鍵詞>' }) — 跨專案認知（不可用時靜默跳過）
+    note: "歷史教訓在 native memory 檔 / `kenaz learn list`；代碼現況用 Grep + kenaz_lsp_references 查"
   ddx_trigger:
     when: "需求類型為 Bug/Fix — 根因不明確時"
     how: "套用 differential_over_intuition protocol — 列出 3+ 可能根因，用客觀數據（日誌、代碼路徑）逐一排除"
@@ -237,93 +230,59 @@ phase_1_requirement_analysis:
 #  Phase 2: 背景調研
 # ═══════════════════════════════════════
 phase_2_research:
-  goal: "用 recall + LSP callers + Grep 建立完整 context — 先查證，再設計任務"
+  goal: "用 LSP callers + Grep 建立完整 context — 先查證，再設計任務"
   actions:
     - "搜尋相關 Feature ID（Grep dev/PRODUCT_SPEC.md）"
-    - "synapse_recall(目標 symbol / 主題) — 已知 risk/decision/fix rune"
     - "kenaz_lsp_callers / kenaz_lsp_references(目標 symbol) — 誰呼叫、誰引用（爆炸半徑）"
     - "Grep/Glob — 探索相關代碼與檔案結構"
-    - "cortex_recall — 查跨專案歷史知識（已知 risk/decision/fix，不止當前專案）"
-    - "cortex_search — 找其他專案的相似實現（避免重複造輪子）"
     - "Grep — 僅用於精確字串匹配（如 error code、常量值、枚舉所有 X）"
     - "查閱類似已完成任務（task-api.js search）"
     - "檢查 .failure/ 相關失敗模式 — 避免重複踩坑"
   caller_driven_research:
-    description: "對核心 symbol 查 recall + LSP callers，驅動 Phase 3 任務設計"
+    description: "對核心 symbol 查 LSP callers，驅動 Phase 3 任務設計"
     note: "核心 symbol 來源：需求描述或 scope_paths 推斷"
     steps:
       - "從需求描述或 scope_paths 推斷核心 symbol"
-      - "對每個核心 symbol → synapse_recall(symbol) + kenaz_lsp_callers(symbol)"
+      - "對每個核心 symbol → kenaz_lsp_callers(symbol) + kenaz_lsp_references(symbol)"
       - "從結果提取："
       - "  scope_paths ← callers/references 所在文件"
       - "  dependencies ← callers/callees 跨文件的真依賴"
       - "  complexity ← caller 數量 + 跨模組數量決定"
-      - "  known_risks ← recall 的歷史 rune 注入 technical_notes"
-    rule: "Phase 3 的 scope_paths 和 dependencies 必須有 LSP / recall 結果支撐，不靠推斷"
-  cross_project_thinking:
-    description: "跨專案調研 — PM 層面主動觸發跨專案知識查詢"
-    rule: "Phase 2 調研時，除了當前專案內的搜尋，必須主動思考跨專案維度"
-    # ─── 強制觸發（不再是建議清單） ───
-    mandatory_recall:
-      rule: |
-        Phase 2 開始時，與 synapse_recall 同步執行 cortex_recall（可並行）：
-        - cortex_recall({ query: '<需求核心關鍵詞>' })
-        - 有結果 → 注入 Phase 3 的 technical_notes（標記 [Cortex] 前綴）
-        - 無結果 → 靜默跳過，不阻塞
-        - cortex 不可用 → 靜默跳過，不阻塞
-      why: "跨專案的 risk/fix/decision rune 是免費的經驗值 — 不查就浪費"
-      parallel_with: "synapse_recall — 兩者無依賴，必須並行呼叫"
-    questions:
-      - "這個需求涉及的概念，在其他專案中有沒有類似的實現或處理方式？→ cortex_search"
-      - "其他專案在相同領域有沒有踩過坑（已知 risk/fix）？這個功能是否可以複用其他專案已有的模組或 pattern？如果是跨專案共用的概念（如 auth、i18n、error handling），是否需要統一方案？→ cortex_recall"
-    when_to_skip:
-      - "cortex_status 顯示無跨專案數據（Phase 0 已偵測）"
-      - "Cortex MCP 不可用（Phase 0 已偵測，graceful degradation）"
-    when_NOT_to_skip:
-      - "❌ 「需求局限於當前專案內部」不是跳過理由 — 其他專案可能踩過同樣的坑"
-      - "❌ 「看起來很簡單」不是跳過理由 — recall 成本極低（一次 FTS5 查詢）"
-  # ─── 空結果協議（recall / callers 回空時的替代策略） ───
+      - "  known_risks ← .failure/ 與 native memory 相關條目注入 technical_notes"
+    rule: "Phase 3 的 scope_paths 和 dependencies 必須有 LSP 結果支撐，不靠推斷"
+  # ─── 空結果協議（callers 回空時的替代策略） ───
   empty_result_protocol:
-    when: "synapse_recall 與 kenaz_lsp_callers 都回空（新功能、新專案、未知領域）"
-    principle: "本地無資料 → 跨專案查詢（Cortex）→ 手動探索 → 保守設計"
+    when: "kenaz_lsp_callers 回空（新功能、新專案、未知領域）"
+    principle: "本地無資料 → 手動探索 → 保守設計"
     phase_2_actions:
-      - "cortex_search({ query: '<功能描述>' }) — 跨專案語義搜尋：其他專案有沒有類似功能的實現？"
-      - "cortex_recall({ query: '<領域關鍵詞>' }) — 跨專案認知回憶：其他專案在同領域踩過什麼坑？有什麼架構決策？這個概念在哪些專案出現過？"
       - "Grep/Glob/Read — 手動探索相關目錄結構和現有 pattern"
       - "查 .failure/ — 類似功能有沒有已知失敗模式"
     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"
-    agent_post_code_emphasis:
-      - "synapse_inscribe — 為新功能留下認知種子（特別重要！這是該領域的第一顆種子）"
-      - "synapse_forge — 如果新功能涉及 3+ symbols → 建立 Sigil 概念節點"
-      - "這些種子是未來 agent 在這個領域的起點 — 寧可多寫不可少寫"
+      - "technical_notes 必須注入：'此任務為新功能/未知領域，無本地 callers 數據。Agent 需自行探索 codebase 並遵循現有 pattern。'"
   # ─── 預言比較（多方案脈衝對比） ───
   prophetic_comparison:
     description: "偵測到多方案時，自動觸發脈衝比較流程"
     trigger: |
       Phase 2 調研過程中偵測到以下任一信號：
       - 需求描述包含選擇（「A 或 B」「可以改 X 也可以改 Y」）
-      - recall/callers 結果顯示多個可行切入點（如 callers 分佈在不同模組）
+      - callers 結果顯示多個可行切入點（如 callers 分佈在不同模組）
       - DDx 產出 2+ 競爭方案
       - Ansuz 自身分析出 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 決策"
     output: "預言比較表格 — 併入 Phase 3 cli_format 輸出給用戶"
     example: |
       需求：「修復 data flow 斷裂，可以改 source 端或改 sink 端」
-      → kenaz_lsp_callers + synapse_recall(source_symbol) → 8 callers, 跨 1 模組, 0 risks
-      → kenaz_lsp_callers + synapse_recall(sink_symbol)   → 22 callers, 跨 3 模組, 2 risks
+      → kenaz_lsp_callers(source_symbol) → 8 callers, 跨 1 模組, 0 risks
+      → kenaz_lsp_callers(sink_symbol)   → 22 callers, 跨 3 模組, 2 risks
       → 結論: 改 source 端 — 爆炸半徑小 3 倍，零歷史風險
-  synapse_fallback:
+  lsp_fallback:
     rule: "kenaz_lsp_* 首次呼叫失敗 → 該 session 降級用 Grep/Glob，不重試"
-  cortex_fallback:
-    rule: "cortex 工具不可用 → 跳過跨專案查詢，不阻塞流程"
   cli_format: |
     🔍 背景調研 + 影響分析
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -331,9 +290,9 @@ phase_2_research:
 
     ⚡ 影響分析: {symbol_name}
     爆炸半徑: {caller_count} callers, {module_crossings} 跨模組（kenaz_lsp_callers）
-    歷史風險: {known_risks 摘要}（synapse_recall）
+    已知風險: {.failure / native memory 摘要}
 
-    相關代碼: {從 callers/recall 提取的檔案路徑}
+    相關代碼: {從 callers 提取的檔案路徑}
     類似任務: {TASK_XXX, TASK_YYY}
     已知風險: {.failure 中的相關模式}
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -343,7 +302,7 @@ phase_2_research:
 #  Phase 3: 任務設計
 # ═══════════════════════════════════════
 phase_3_task_design:
-  goal: "用 recall + callers 結果拆解需求為獨立、可執行的任務 — 證據驅動，不靠推斷"
+  goal: "用 callers 結果拆解需求為獨立、可執行的任務 — 證據驅動，不靠推斷"
   ddx_trigger:
     when: "需求有多種實作方案、或涉及架構決策時"
     how: "套用 differential_over_intuition protocol — 列出 2+ 方案，用客觀證據排序後選最優"
@@ -353,31 +312,31 @@ phase_3_task_design:
     rule: |
       DDx 識別出 2+ 方案後，不可直接靠推斷選方案。
       必須檢查 Phase 2 是否已有預言比較結果：
-      - 有 → 直接引用 callers/recall 數據做選擇
-      - 無 → 此刻補跑：對每個方案目標 symbol 各跑 kenaz_lsp_callers + synapse_recall，填入比較表格
+      - 有 → 直接引用 callers 數據做選擇
+      - 無 → 此刻補跑：對每個方案目標 symbol 各跑 kenaz_lsp_callers + kenaz_lsp_references，填入比較表格
     decision_flow: |
       DDx 列出方案 → 預言比較量化風險 → 結構數據選方案 → 用選中方案驅動任務設計
       (鑑別回答「有哪些選擇」→ 預言回答「選哪個」→ 任務設計用選中方案的 scope)
     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」）
   impact_driven_design:
-    principle: "Phase 2 的 recall + LSP callers 結果是任務設計的輸入，不是參考"
+    principle: "Phase 2 的 LSP callers 結果是任務設計的輸入，不是參考"
     scope_from_callers: "scope_paths = kenaz_lsp_callers/references 涉及的文件路徑（不猜，以 LSP 結果為準）"
     deps_from_callers: "dependencies = callers/callees 跨文件的真依賴（B 的輸入包含 A 的輸出才算）"
     complexity_from_callers: |
       simple: callers < 10 且無跨模組
       medium: callers 10-30 或跨 1-2 個模組
       complex: callers > 30 或跨 >= 3 個模組
-    risks_from_recall: "synapse_recall 的歷史 rune → 注入任務的 technical_notes"
+    risks_from_memory: ".failure/ 與 native memory 的相關條目 → 注入任務的 technical_notes"
     implementors_check: "kenaz_lsp_references 找到的 implementor 檔案必須在某個任務的 scope_paths 中"
   actions:
     decomposition:
       - "每個任務 1-8 小時可完成"
       - "任務之間盡量獨立 — 真依賴才序列，假依賴並行"
-      - "定義 scope_paths — 從 callers/recall 結果提取，確保並行安全"
+      - "定義 scope_paths — 從 callers 結果提取，確保並行安全"
       - "分配 agent_type（見 agent_assignment）"
     sizing:
       small: "單一修改 → 不拆，一個任務"
@@ -832,15 +791,13 @@ phase_9_result_verification:
     - "kenaz_lsp_callers — 分析變更的影響範圍（誰呼叫了被修改的函數？誰引用了被修改的模組？）"
     - "無引入 regression？（結合 kenaz_lsp_callers + 人工檢查影響範圍內的功能）"
   cognitive_checkpoint:
-    rule: "驗證完成後，必須判斷是否需要 inscribe。不可跳過此判斷"
+    rule: "驗證完成後，必須判斷是否有值得記錄的教訓（`kenaz learn add` 或 native memory 檔）。不可跳過此判斷"
     check: |
       問自己：這次修復/實作有沒有值得記錄的知識？
-      - 定位了 non-obvious 的 bug 根因？ → inscribe type=fix
-      - 發現隱藏的 side-effect 或使用限制？ → inscribe type=risk
-      - 做出了非顯然的設計決策？ → inscribe type=decision
-      - 識別出跨 3+ symbol 的概念？ → forge Sigil
+      - 定位了 non-obvious 的 bug 根因？ → 記錄（fix）
+      - 發現隱藏的 side-effect 或使用限制？ → 記錄（risk）
+      - 做出了非顯然的設計決策？ → 記錄（decision）
       - 以上都沒有 → 跳過，不為了寫而寫
-    verify_runes: "如果 agent 寫了 rune，交叉比對原始碼判斷準確性 → 不準確的 rune 以 supersedes 取代"
   on_success:
     - "node {CORE}/.collaboration/core/task-api.js [--project-path {PROJECT_PATH}] complete TASK_XXX"
     - "→ 觸發 prevention_analysis（如符合條件）"
@@ -1049,7 +1006,6 @@ phase_11_report:
     🔀 Git: task/task_xxx → {user_branch}
 
     {如有預防分析，附加 🛡️ 預防建議區塊}
-    {如有寫入 rune，附加 🧠 認知層更新區塊}
     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   # ─── 失敗回報 ───

package/core/.specialist/Forseti/core.yaml

@@ -23,7 +23,6 @@ workflow:
       - "讀取 task YAML → 取得 scope_paths、required_env、title"
       - "取得 git HEAD commit SHA（git rev-parse --short HEAD）"
       - "確認 .forseti/evidence/{task_id}/ 目錄存在（不存在則建立）"
-      - "synapse_recall(query='Forseti verification task_id scope', projectPath) → 檢查是否有已知 risk rune"
     on_task_not_found: "輸出 'ᚠ Forseti: task {task_id} not found. Abort.' 並退出"
     output: "boot_context = { task_id, branch, commit_sha, scope_paths, required_env, known_risks[] }"
 
@@ -114,10 +113,9 @@ workflow:
         primary: "POST http://127.0.0.1:18080/api/forseti/verdict（含完整 verdict JSON）"
         fallback: "若 POST 失敗 → 檔案已存在，不重複寫入"
         task_update: "task-api update {task_id} --notes='Forseti: {overall} | L1:{l1} L2:{l2} L3:{l3}'"
-      memory_inscription:
+      lessons:
         - "回顧執行過程中的 non-obvious 發現"
-        - "符合條件者 → synapse_inscribe（英文，confidence >= 0.65）"
-        - "若 3+ symbol 構成異常模式 → 評估 synapse_forge Sigil"
+        - "符合條件者 → `kenaz learn add` 或 native memory 檔"
       console_report:
         - "輸出結構化報告（格式見下方 report_format）"
     report_format: |
@@ -148,9 +146,6 @@ degradation:
   task_api_fail:
     action: "從 .kenaz/tasks/active/ 直接讀取 task YAML 作為 fallback"
     note: "task-api 不可用不應阻止驗證"
-  synapse_unavailable:
-    action: "跳過 recall/inscribe 步驟，繼續驗證流程"
-    note: "Synapse 不可用不影響驗證本身，只影響 rune 沉澱"
   verdict_api_fail:
     action: "已寫入 .forseti/verdicts/ — 不重複嘗試 POST"
   playwright_not_installed:

package/core/.specialist/Forseti/rule.yaml

@@ -35,7 +35,7 @@ identity:
     - "✅ Evidence-Based：所有 verdict 必須附上命令輸出、截圖、日誌等證據"
     - "✅ 三層遞進：Level 1（build）→ Level 2（probe）→ Level 3（E2E），逐層執行"
     - "✅ 早停原則：Level 1 FAIL → 直接回傳 FAIL，不執行 Level 2/3"
-    - "✅ 寫 Rune：發現驗證模式或系統限制 → synapse_inscribe"
+    - "✅ 記錄教訓：發現驗證模式或系統限制 → `kenaz learn add`"
     - "❌ 不修改 source code — 只執行驗證命令，不觸碰實作"
     - "❌ 不規劃任務 — 那是 Ansuz 的事"
     - "❌ 不 dispatch agent — 那是 Amelia 的事"

package/core/.specialist/Heimdall/SKILL.md

@@ -1,7 +1,7 @@
 # ᚺ Heimdall — Code Health Guardian
 
-Heimdall 是代碼健康守望者：git 驅動的代碼健康審查，用 `kenaz_lsp_callers` / `kenaz_lsp_references` 看影響範圍、用 `synapse_recall` 看已知風險，生成 OptimizationProposal。
-記憶庫健康分數（`synapse_health`，memory-v1）只做趨勢紀錄，**不做 KEEP/REVERT 判決，不會回退任何 commit**。
+Heimdall 是代碼健康守望者：git 驅動的代碼健康審查，用 `kenaz_lsp_callers` / `kenaz_lsp_references` 看影響範圍、用 `.failure/` 與 `kenaz learn list` 看已知風險，生成 OptimizationProposal。
+記憶庫健康分數（memory-v1）只做趨勢紀錄，**不做 KEEP/REVERT 判決，不會回退任何 commit**。
 
 ---
 
@@ -59,7 +59,6 @@ post_complete_verdict: RECORDED | delta: {N.NN|n/a} | reason: {text}
 
 | 系統 | 關係 |
 |------|------|
-| Synapse | 記憶（recall/inscribe/forge）；`measureHealthScoreSync` 調用 `/api/mcp` synapse_health 取趨勢分數 |
 | kenaz_lsp_* | 程式碼導航：callers / references / definition / symbols |
 | post-complete.js | Step 4 紀錄記憶健康趨勢，不回退 |
 | task-api | 寫入 `post_complete_verdict: RECORDED` 到 task YAML |

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

@@ -17,29 +17,25 @@ capabilities:
         tool: "git diff-tree + kenaz_lsp_symbols + kenaz_lsp_callers"
       scheduled:
         input: "無 — 定時掃描"
-        scope: "全項目健康掃描（stale rune / 跨專案風險）"
-        tool: "synapse_recall + cortex_sync"
+        scope: "全項目健康掃描"
+        tool: "kenaz_lsp_symbols + kenaz_lsp_callers"
       manual:
         input: "用戶指定 symbol 或 path"
         scope: "指定範圍的深度分析"
-        tool: "kenaz_lsp_callers + kenaz_lsp_references + synapse_recall"
+        tool: "kenaz_lsp_callers + kenaz_lsp_references"
     rules:
       - "✅ 觸發類型決定分析廣度 — commit 掃描不等於全局掃描"
       - "❌ 不在 commit 觸發時做全項目掃描 — 代價不成比例"
 
   # ─── 代碼健康分析 ───
   code_health_analysis:
-    description: "用 recall + LSP callers 偵測代碼健康訊號"
+    description: "用 LSP callers + .failure/ 偵測代碼健康訊號"
     analysis_battery:
       commit_analysis:
         step_1: "git diff-tree COMMIT_SHA → changed_files → kenaz_lsp_symbols → changed_symbols"
         step_2: "kenaz_lsp_callers(each changed symbol, depth=2) → blast_radius"
-        step_3: "synapse_recall(changed symbols + impacted symbols) → known_risks"
+        step_3: ".failure/ + `kenaz learn list` 中與 changed + impacted symbols 相關的條目 → known_risks"
         step_4: "交叉分析：known_risks ∩ blast_radius → 高優先警報"
-      health_scan:
-        stale_runes: "synapse_recall(query='risk') → filter confidence > 0.7 → 比對是否仍存在對應 symbol"
-    thresholds:
-      risk_rune_min_confidence: 0.7
 
   # ─── 提案生成 ───
   proposal_generation:
@@ -47,11 +43,11 @@ capabilities:
     # ─── AXON metadata schema contract ───
     # OptimizationProposal.metadata is serde_json::Value — no Rust struct change needed.
     # Heimdall writes affected_symbols[] and axon_verdict='pending' for axon_eligible categories.
-    # AXON bridge (TASK_840) writes axon_verdict and synapse_evidence after analysis.
+    # AXON bridge (TASK_840) writes axon_verdict and evidence after analysis.
     metadata_schema:
       affected_symbols:
         type: "string[]"
-        format: "file_path:symbol_name:kind  (same as synapse_inscribe symbol_id)"
+        format: "file_path:symbol_name:kind"
         written_by: "Heimdall Phase 3"
         description: "All symbol stable IDs referenced in Phase 1 findings for this proposal"
       axon_verdict:
@@ -59,56 +55,38 @@ capabilities:
         written_by: "Heimdall Phase 3 (initial 'pending'), AXON bridge (final verdict)"
         description: "auto = AXON will auto-apply; skip = not eligible or insufficient evidence; pending = awaiting AXON analysis"
         default: "'pending' for axon_eligible categories; absent for non-eligible"
-      synapse_evidence:
+      evidence:
         type: "object (optional)"
         written_by: "AXON bridge only"
         fields:
-          recall_summary: "string — synapse_recall findings summary"
           impact_summary: "string — kenaz_lsp_callers blast radius summary"
-          health_trend: "string — health score trend context"
           context_summary: "string — kenaz_lsp_references summary"
 
     proposal_categories:
       bug_fix:
-        trigger: "changed symbol ∩ HIGH risk rune"
-        source_field: "code_watch:risk_rune"
-        template: "此次修改觸及已知高風險區域：{rune_content}。建議驗證 {affected_symbols}。"
+        trigger: "changed symbol ∩ 已知 HIGH risk"
+        source_field: "code_watch:known_risk"
+        template: "此次修改觸及已知高風險區域：{risk_content}。建議驗證 {affected_symbols}。"
         axon_eligible: true
       security:
-        trigger: "risk rune type=security 的 symbol 被改動"
-        source_field: "code_watch:security_rune"
-        template: "安全敏感 symbol {name} 被修改，已知風險：{rune_content}。"
+        trigger: "已知 security risk 的 symbol 被改動"
+        source_field: "code_watch:security_risk"
+        template: "安全敏感 symbol {name} 被修改，已知風險：{risk_content}。"
         axon_eligible: false  # security proposals require human review — AXON must not auto-apply
-      cross_project:
-        trigger: "cortex_sync 偵測到跨專案 SIMILAR_TO 模組對，且來源模組有未解決 risk rune，目標模組無對應知識"
-        source_field: "cortex:cross_project:{module_pair_hash}"
-        template: "Cross-project risk bridge: '{project_a}' has unresolved risk in module '{module_a}' (similarity {pct}%) that may apply to '{module_b}' here."
-        trigger_constraint: "scheduled_only — commit trigger 不執行此掃描（代價不成比例）"
-        cooldown: "30 天/模組對（global_memory.cross_project_proposal_log）"
-        dedup: "7 天內相同 source key 不重複（與其他 proposal 類型一致）"
-        not_triggered_when: "來源專案對同 symbol_id 已有 fix rune（已解決不重複通報）"
-        axon_eligible: false  # cross-project proposals span repo boundaries — AXON scope is single-project
     quality_gate:
-      - "每筆 proposal 必須包含：source（Synapse query type）、affected_files、description（含數據）"
-      - "同一 source 在 7 天內（以 created_at 計）已有 Pending/Accepted proposal 才去重；超過 7 天不再阻擋（TASK_2251）；code_watch/cortex 來源 pending 超過 30 天由 gc_stale_proposals 過期"
+      - "每筆 proposal 必須包含：source（分析類型）、affected_files、description（含數據）"
+      - "同一 source 在 7 天內（以 created_at 計）已有 Pending/Accepted proposal 才去重；超過 7 天不再阻擋（TASK_2251）；code_watch 來源 pending 超過 30 天由 gc_stale_proposals 過期"
       - "已被 ignored 的 proposal 類型 → 降低相同觸發條件的優先級"
     output_api:
       method: "POST http://127.0.0.1:18080/api/proposals/create"
       fallback: "寫入 {project_path}/OPTIMIZATION_PROPOSALS.json"
 
   # ─── 記憶寫入 ───
-  memory_inscription:
-    description: "把分析過程中發現的 non-obvious 知識永久化到 Synapse"
-    when_to_inscribe:
-      - "發現 high-impact symbol 沒有任何 rune → 寫入 risk rune"
-      - "同一 symbol 第二次觸發同類警報 → 提升 confidence，加 supersedes"
-      - "發現跨 3+ symbol 的異常模式 → 評估 synapse_forge Sigil"
-      - "問題確認已修復 → synapse_inscribe(supersedes=<舊 rune_id>)（讓舊 rune 退場）"
-    format:
-      symbol_id: "file_path:symbol_name:kind"
-      types: ["risk", "pattern", "fix", "insight"]
-      min_confidence: 0.65
-      language: "English（遵循 feedback_rune_sigil_english.md）"
+  lessons:
+    description: "把分析過程中發現的 non-obvious 知識記下來"
+    when_to_record:
+      - "發現 high-impact symbol 的隱藏風險 → `kenaz learn add` 或 native memory 檔"
+      - "同一 symbol 第二次觸發同類警報 → 更新既有條目，不重複寫"
 
   # ─── 掃描報告 ───
   scan_report:
@@ -126,8 +104,7 @@ capabilities:
 
       Actions:
         ✍ Proposals written: {N}
-        🧠 Runes inscribed:  {N}
-        ♻ Runes updated:    {N}
+        🧠 Lessons added:    {N}
       ══════════════════════
     rules:
       - "無發現 → 輸出 'ᚺ Heimdall: clean scan. No signals.' 即可，不展開"