kenaz 0.3.9 → 0.3.11

package/core/.specialist/tools/session.js

@@ -9,7 +9,7 @@
  * CLI:
  *   node session.js list [--json]
  *   node session.js resolve <name>
- *   node session.js prompt <name> [--mode=assembled|reference] [--depth=capsule|elixir|kernel] [--exclude=a,b] [--task=...] [--context=...] [--source=plugin] [--no-episode]
+ *   node session.js prompt <name> [--mode=assembled|reference] [--depth=capsule|elixir|kernel] [--exclude=a,b] [--task=...] [--context=...] [--source=plugin]
  *   node session.js start <name> [--consumer=...] [--task=...] [--with-prompt] [--json]
  *   node session.js end <sessionId>
  *   node session.js active [--json]
@@ -76,8 +76,6 @@ const PROJECT_DIR = (() => {
   return BASE_DIR;
 })();
 
-// Specialists whose `prompt` boot gets the most recent episode injected as prior-session context.
-const EPISODE_SPECIALISTS = ['Ansuz', 'Amelia'];
 const http = require('http');
 const projectResolver = require('./lib/project-resolver');
 // TASK_2163: chart files are keyed by project identity + id (sub-projects reusing
@@ -161,7 +159,7 @@ function buildAnsuzBootCapsule(spec, selfModel) {
     lazy_load: [
       'Load full kernel/capability files only when the current task needs their detailed rules.',
       'Load full self_model only when updating identity, auditing drift, or resolving a blind spot.',
-      'Use synapse_recall for symbols, and kenaz_lsp_callers for callers, before modifying code paths with broad blast radius.',
+      'Use kenaz_lsp_references / kenaz_lsp_callers before modifying code paths with broad blast radius.',
     ],
     self_model: summarizeSelfModelForBootCapsule(selfModel),
   };
@@ -1028,73 +1026,6 @@ function buildReferencePrompt(spec, { task, context, exclude }) {
   return sections.join('\n');
 }
 
-// ═══════════════════════════════════════
-//  Hippocampus: Episodic Memory Recall
-// ═══════════════════════════════════════
-
-/**
- * Recall the most recent episode from Hippocampus via MCP HTTP API.
- * Used in Ansuz prompt assembly to inject prior session context.
- * Graceful degradation: returns null if Dashboard/Hippocampus unavailable.
- * @param {number} limit - Max episodes to recall (default: 1)
- * @param {string|null} agentRole - Optional agent_role filter (e.g. 'ansuz', 'amelia').
- *   When provided, only episodes with matching agent_role are returned.
- *   When null, all episodes are returned (backwards compatible).
- * @returns {Promise<string|null>} Formatted episodic memory section, or null
- */
-function recallRecentEpisode(limit = 1, agentRole = null) {
-  return new Promise((resolve) => {
-    const recallArgs = { limit, projectPath: PROJECT_DIR };
-    if (agentRole) recallArgs.agent_role = agentRole;
-    const payload = JSON.stringify({
-      jsonrpc: '2.0', id: 1,
-      method: 'tools/call',
-      params: { name: 'hippocampus_episode_recall', arguments: recallArgs },
-    });
-
-    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(payload) },
-      timeout: 5000,
-    }, (res) => {
-      let body = '';
-      res.on('data', (c) => { body += c; });
-      res.on('end', () => {
-        try {
-          const result = JSON.parse(body);
-          const text = result?.result?.content?.find(c => c.type === 'text')?.text;
-          if (!text) return resolve(null);
-
-          const data = JSON.parse(text);
-          const episodes = data.episodes || [];
-          if (episodes.length === 0) return resolve(null);
-
-          const lines = ['# ═══ Episodic Memory (from Hippocampus) ═══', ''];
-          lines.push(`Last ${episodes.length} session(s):`);
-          for (const ep of episodes) {
-            const epData = ep.episode || ep;
-            lines.push(`\n### ${epData.task_id || epData.id || 'unknown'}`);
-            if (epData.summary) lines.push(epData.summary);
-            if (epData.lesson) lines.push(`**Lesson**: ${epData.lesson}`);
-            const entries = ep.entries || [];
-            for (const entry of entries.slice(0, 5)) {
-              lines.push(`- **${entry.phase || 'note'}**: ${entry.content || ''}`);
-            }
-          }
-          resolve(lines.join('\n'));
-        } catch {
-          resolve(null);
-        }
-      });
-    });
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
-    req.write(payload);
-    req.end();
-  });
-}
-
 /**
  * Find the current Claude Code conversation JSONL file.
  * Claude Code writes real-time conversation data to:
@@ -1685,23 +1616,6 @@ async function cli() {
         let prompt = await buildPrompt(name, { mode, task: flags.task, context: flags.context, exclude, source, depth,
           externalBootContext: flags['external-boot-context'] === true });
 
-        // Inject the most recent episode as prior-session context for interactive boots.
-        // --no-episode (legacy alias --no-muninn, still passed by k-cli): skip it for
-        // headless/programmatic callers (e.g. kenaz_specialist_dispatch).
-        if (EPISODE_SPECIALISTS.includes(name) && mode === 'assembled' && !flags['no-episode'] && !flags['no-muninn']) {
-          // TASK_2218: the real project pin is written by .claude/hooks/ansuz-session-pin.js,
-          // keyed by the hook-payload session_id -- nothing is pinned here.
-
-          // Prompt injection: skip in lean modes to keep prompt lean.
-          if (depth !== 'kernel' && depth !== 'capsule' && depth !== 'elixir') {
-            // Hippocampus: inject most recent episode as prior session context
-            const episodicMemory = await recallRecentEpisode(1, name.toLowerCase());
-            if (episodicMemory) {
-              prompt += `\n\n${episodicMemory}\n`;
-            }
-          }
-        }
-
         console.log(prompt);
         break;
       }
@@ -1858,7 +1772,6 @@ if (require.main === module) {
     cleanSessions,
     cleanOrphanedClaude,
     classifyOrphanCandidates, // exported for testing (TASK_1917) — same function production uses
-    recallRecentEpisode,
     findConversationLog,
     // Identity verification (TASK_1080)
     identityScore: (name, opts) => require('./identity-scorer').score(name, { projectPath: BASE_DIR, ...opts }),

package/core/.system/memory/README.md

@@ -1,3 +1,6 @@
+> REMOVED 2026-10-11 (TASK_2411): the memory system (Synapse/Hippocampus/Cortex/Alaya recall) no longer exists in code.
+> Kept for history only; do not follow it. Lessons now: `kenaz learn` and native memory files.
+
 # .memory 記憶系統
 
 ## 系統概述

package/core/CLAUDE.md

@@ -41,7 +41,7 @@ session 開始時先鎖定語言（對照用戶第一條訊息 + cwd/CLAUDE.md
 - 修改非 trivial symbol 前：用 `kenaz_lsp_references` / `kenaz_lsp_callers` 看影響範圍（FAIL-009）。trivial 改動可跳過。
 - 所有 `kenaz_lsp_*` 呼叫必須明確帶 `projectPath`。
 
-**記憶系統凍結（2026-10-10）**：Synapse / Hippocampus / Cortex / Alaya 不再是必要步驟——不主動呼叫 `synapse_*`、`hippocampus_*`、`cortex_*`、`alaya_*`，不在 prompt 或規則加 recall/inscribe。依據：14 天內 recall 結果只有約 4.7% 被採用，且多為規則強制呼叫。經驗與教訓改記在 Claude Code 原生記憶檔（下方分層）。資料與程式碼保留，約 2026-10-24 再決定是否刪除。
+**記憶系統已移除（2026-10-11，TASK_2411）**：Synapse / Hippocampus / Cortex recall / embeddings 與 Alaya seeds/bijas 已移除，`synapse_*`、`hippocampus_*`、`cortex_*`、`alaya_recall` 不再存在；教訓用 `kenaz learn add` 與 Claude 原生記憶檔；`~/.kenaz/cortex/*.db` 與 `.synapse/` 資料留在磁碟上、不再開啟。
 
 ---
 
@@ -59,11 +59,11 @@ harness 預設「每條記憶都在 MEMORY.md 加一行」；本專案改為三
 ## 專案概述
 
 KenazAI 是一個 Claude Code 多 Agent 協作系統，包含：
-- **Kenaz Dashboard**：Tauri 2 + Next.js + Rust 桌面應用（`dashboard/`）
+- **kenaz-server**：Rust 後端（`dashboard/src-tauri/`，npm `@kenazai/server-*`）；Dashboard 桌面版已於 2026-10-11 退役（TASK_2396）
 - **Specialist 系統**：AI Agent 調度引擎（`.specialist/`）
 - **Formation 系統**：多 Agent 協作調度，支援 unit/solo/squad/legion 陣型（`.formation/`）
 
-技術棧：Rust（Tauri backend + Synapse 記憶）、TypeScript/React（frontend）、SQLite FTS5（Synapse 記憶）
+技術棧：Rust（kenaz-server）、Node.js（kenaz CLI、hooks、工具）、SQLite
 
 ---
 
@@ -132,8 +132,7 @@ node .collaboration/core/task-api.js move TASK_XXX active  # 移動狀態
 |------|------|------|
 | 規則庫 | `.rule/` | 最高優先級規則，見 `INDEX.yaml` |
 | 失敗學習 | `.failure/` | 已知失敗模式，Agent 執行前應檢查 |
-| Synapse | `dashboard/src-tauri/src/features/synapse/` | Rust-native 記憶層（2026-10-10 凍結，見上方說明） |
-| Rust 測試 | `npm run test:rust -- <filter>` | 主目錄直接可跑；用共用短路徑 target，不和 live tauri dev 搶 `target/` 鎖。勿直接 `cargo test` |
+| Rust 測試 | `npm run test:rust -- <filter>` | 主目錄直接可跑；用共用短路徑 target，不和其他建置搶 `target/` 鎖。勿直接 `cargo test` |
 | Formation | `.formation/` | 多 Agent 調度，見 `README.md` |
 | Skills | `.claude/skills/` | Agent 行為定義（40+ skills） |
 | 外部 Skills | `.agents/skills/` | `vercel-react-best-practices`、`supabase-postgres-best-practices` |
@@ -163,10 +162,10 @@ DB:     postgresql://postgres:postgres@127.0.0.1:54322/postgres
 .collaboration/     # 任務系統
 .formation/         # Formation 調度
 .failure/           # 失敗學習系統
-.memory/            # Synapse 記憶
+.memory/            # （歷史）舊記憶資料，記憶系統已移除
 .claude/            # Skills、Commands、Hooks
 .agents/            # 外部 Skills
 dev/scripts/        # CLI 工具
 dev/PRODUCT_SPEC.md # 產品規格
-dashboard/          # Kenaz Dashboard（Tauri + Next.js + Rust）
+dashboard/src-tauri/ # kenaz-server（Rust）；dashboard/scripts/ 打包與安裝腳本
 ```

package/core/KENAZ_CORE_VERSION

@@ -1 +1 @@
-0.3.9
+0.3.11

package/core/dev/plans/CLI_FIRST_INSTALL_FLOW.md

@@ -126,3 +126,29 @@ Layout: `packages/kenaz` (CLI + staged kenaz-core), `packages/server-{win32-x64,
 ### doctor 為什麼檢查 plugin 路徑
 
 Dashboard 執行時（`peer_mod.rs`）會重新登錄自己 kenaz-core 內的 `kenaz-peer`；自 TASK_2384 起登錄會取代舊副本，所以重新啟動 Dashboard 會把 `CLAUDE_CODE_PLUGIN_DIRS` 的 `kenaz-peer` 改回它的路徑。`kenaz doctor` 會列出：Dashboard 是否執行 / 已安裝、18080 的持有者、`CLAUDE_CODE_PLUGIN_DIRS` 是否指向 Dashboard 的 core。
+
+### Dashboard 退役 (TASK_2396，2026-10-11)
+
+Dashboard（Tauri 桌面 app + Next.js 前端）已從 repo 移除，`kenaz-server` 是唯一後端，`cargo build`（預設 feature `server`）直接產出它。
+
+- 已安裝的 Dashboard 不會被動到：最後一版安裝檔與 Supabase `kenaz-release/latest.json` 都保留，既有安裝可繼續用，但不會再收到更新。
+- 遷移步驟同上方「給使用者的步驟」：結束 Dashboard、關閉「開機時啟動」、`npx kenaz install`、`/kenaz init`、`npx kenaz doctor`。資料（專案、憑證、任務、記憶）都在 `~/.kenaz` 與 `<專案>/.kenaz`，不需搬移。
+- 回到舊版 Dashboard 只能用當初的安裝檔；repo 內不再有它的建置腳本（`build:kenaz`、`publish-release`、`editions/`、`PUBLISH_UPDATE`）。
+
+gui 行為去向（盤點自 `gui_app.rs`、`commands.rs`、`updater.rs`、24 個 `#[cfg(feature = "gui")]`）：
+
+| 行為 | 去向 |
+|---|---|
+| HTTP/MCP 啟動、port fallback、health watchdog、peer/presence/claude provision pollers | 已在 `server_boot::start_http_server`（TASK_2357/2369） |
+| PluginManager + MCP servers、Yggdrasil remote poll、field report loops | 已在 `start_headless_services`（TASK_2369/2394） |
+| KENAZ_SOURCE_DIR 解析、mcp.json 擁有者規則、env/tracing 初始化 | 已在 `server_boot`（`resolve_server_source_dir`、`should_rewrite_mcp`、`init_process`） |
+| 自動更新 | 已由 `infrastructure/self_update.rs` 取代（ed25519 簽章 feed）；Tauri updater 與 `/api/dashboard/*` 更新路由刪除 |
+| 視窗、splash、webview 重啟守衛、WTS 解鎖監看 | 刻意移除（無 webview） |
+| 系統匣、close-to-tray、開機自啟 | 刻意移除（服務由 `kenaz install` 的 service launcher 負責） |
+| `kenaz://` deep link、single-instance、Agent Hub 核准卡 | 刻意移除（hub 的 sites/sessions 狀態與 HTTP 路由保留） |
+| 語音 PTT、剪貼簿/檔案選取 tauri command、pty-server sidecar、claude-bridge、Next.js sidecar | 刻意移除（只有前端使用） |
+| Tauri `#[tauri::command]` 包裝（scheduler、single_agent、script、config 等） | 刻意移除；對應 HTTP 路由原本就存在，函式本體保留 |
+| `.env.local` 載入與 TUNNEL_SIGNING_SECRET 自動產生、tunnel token 寫回 | 未搬：kenaz-server 不載入 `.env.local`，tunnel 相關環境變數須自行以環境變數提供（見交接回報的未驗證項） |
+| 啟動時 `auto_seed_project_config`（寫入 `~/.kenaz/projects.json` 的 core 項目） | 未搬：由 `kenaz install` / `/kenaz init` 登錄專案 |
+| 啟動時 cortex seed merge（`merge_seed_if_needed`） | 刻意移除（記憶系統凍結，merge 核心 `merge_seed_at` 留待記憶卡處理） |
+| 退出清理與 self-kill watchdog | 刻意移除；kenaz-server 在 ctrl-c 時關閉 LSP 並 shutdown HTTP |

package/core/plugins/kenaz/INVENTORY.md

@@ -37,7 +37,7 @@ Hooks only act in Kenaz projects (`.kenaz/project.yaml`, `_project-guard.js`): r
 | Class | Skills |
 |---|---|
 | ship (34) | architect_agent, assessment_agent, backend_agent, backend_engineer, code_reviewer, dev_agent, designer, developer, feature_agent, frontend_agent, incident_response, product_manager, qa_engineer, security_agent, spec_optimizer, sre_agent, adapt, animate, audit, bolder, clarify, colorize, critique, delight, distill, extract, frontend-design, harden, normalize, onboard, optimize, polish, quieter, ui-ux-pro-max |
-| core | heimdall, huginn, synapse_maintain, sunny, optimization_agent |
+| core | heimdall, huginn, sunny, optimization_agent |
 | retire | legacy_dev |
 | third-party / domain (not shipped; install separately from .agents/skills) | vercel-react-best-practices, supabase-postgres-best-practices, remotion-best-practices, pcb-review |
 

package/core/plugins/kenaz/commands/Ansuz.md

@@ -14,7 +14,7 @@ ARGUMENTS 含 `[專案: X]` 或 `--project-path X` → PROJECT_PATH = X，下方
 - **自己做**：小而明確的修正（約 30 行內、單一檔案或少數檔案）→ 直接改，跑最近的測試，提交。
 - **開卡派工**：中型、可平行、或高風險路徑的工作：
   1. 用 `kenaz_task_create` 開卡（`projectPath` = 目前專案；寫清楚 requirements、acceptance criteria、scope paths）。查卡、改狀態用 `kenaz_task_list` / `kenaz_task_get` / `kenaz_task_update`。
-  2. 產生派工內容：`node "${CLAUDE_PLUGIN_ROOT}/hooks/core-resolve.js" .formation/tools/dispatch.js --skill=do --task=TASK_XXX --dispatch-mode=subagent`（加 `--project-path`；Codex 加 `--harness=codex`）。把輸出 JSON 的 `promptText` 交給 subagent，`agentParams` 照用（模型不要自己換）。
+  2. 產生派工內容：`node "${CLAUDE_PLUGIN_ROOT}/hooks/core-resolve.js" .formation/tools/dispatch.js --skill=do --task=TASK_XXX --dispatch-mode=subagent`（有 PROJECT_PATH 加 `--project-path`）。把輸出 JSON 的 `promptText` 交給 subagent，`agentParams` 照用（模型不要自己換）。
   3. subagent 在 worktree 裡改完並 commit；你驗證後合併。
 - 開卡前先確認 scope 與驗收條件對準真正的問題，不要照著錯的假設派工。
 
@@ -23,24 +23,20 @@ ARGUMENTS 含 `[專案: X]` 或 `--project-path X` → PROJECT_PATH = X，下方
 - 有**對照組**：證明測試在舊程式上會失敗，或修改前後結果不同。
 - subagent 回報「未驗證」的項目，由你補驗或明講仍未驗證。
 - 合併：`git merge` 後跑相關測試（或 `node "${CLAUDE_PLUGIN_ROOT}/hooks/core-resolve.js" .specialist/Ansuz/tools/verify-and-land.js`），用這個專案自己的測試指令。
-- 檔案長度：verify-and-land 合併前會跑 `check-file-size`（警告 1000 / 上限 2000 行，既有超長檔只擋「未配套拆分的增長」）；被擋就按職責拆成 module / component / hook。
-- 只在 Kenaz 核心 repo 本身：Rust 測試走 `npm run test:rust` / `dev/scripts/rust-verify-worktree.js`。
 
-## 回報
-用用戶的語言。說清楚：做了什麼、怎麼驗證的、還有什麼沒驗證或需要用戶決定。不說「應該可以」。
+## 回報與提問
+- 一律用用戶的語言（中文訊息 → 中文回覆，含提問選項）。
+- 需要用戶決定時用 `AskUserQuestion`（2-4 個選項、建議的放第一個），不要在文字裡列選項等回覆；有證據能自己判斷的事不問。
+- 回報說清楚：做了什麼、怎麼驗證的、還有什麼沒驗證或需要用戶決定。不說「應該可以」。
 
-## Kenaz 本身出問題時：先回報再繞過（wish / field report）
-Kenaz 的工具、hook、安裝、peer 訊息、派工擋住或拖慢工作時（指令失敗、回傳錯的資料、少了能力、行為不如預期），**繞過之前**先呼叫 `kenaz_wish_create`。scope=kenaz 的 wish 會自動送到 Kenaz 團隊成為 field report。
-- `projectPath`：目前專案路徑；`scope`：`kenaz`（Kenaz 本身的問題）或 `project`（只跟這個專案有關）
-- `wish_type`：`bug`（壞了）／`feature`（缺能力，內容寫：需求、現在哪裡不夠、建議做法、還有誰受益）／`question`
-- `content`：一行重現步驟 + 預期 vs 實際 + 版本（`npx kenaz doctor` 那幾行）；附上 session id。不要貼金鑰或 token。
-- 一個問題只報一次；報完照常用替代做法把工作完成，並在回報裡告訴用戶已送出 wish。
-- 用戶直接說「回報這個問題」時也用同一個工具（`source`=`user`）。
+## Kenaz 本身出問題時：先回報再繞過
+Kenaz 的工具、hook、安裝、peer、派工擋住或拖慢工作時，**繞過之前**先 `kenaz_wish_create`（`projectPath`；`scope` kenaz|project；`wish_type` bug|feature|question；`content` = 一行重現 + 預期 vs 實際 + `npx kenaz doctor` 版本 + session id，不貼金鑰）。一個問題報一次，報完照常完成工作並告訴用戶；用戶說「回報這個問題」也用它（`source`=`user`）。
 
 ## 自主模式
-用戶明確授權自主（「自主」「不用問我」「自己判斷著做」）時：立刻執行 `node "${CLAUDE_PLUGIN_ROOT}/hooks/core-resolve.js" .specialist/tools/autonomy.js grant --session <id> --scope "<授權範圍>"`，再讀 RULES.md 的 Autonomy 一節。之後 Turn Context 會顯示 `[autonomy] ON`，結束回合會被 Stop hook 擋回：自己決定、一路做完，不在回合結尾問「要我…嗎？」；只有 RULES.md 列的必要停點才 `pause`，做完才 `done`。
+用戶明確授權自主時：立刻 `node "${CLAUDE_PLUGIN_ROOT}/hooks/core-resolve.js" .specialist/tools/autonomy.js grant --session <id> --scope "<範圍>"`，讀 RULES.md 的 Autonomy。之後結束回合會被 Stop hook 擋回：自己決定、一路做完，不在結尾問「要我…嗎？」；只有必要停點才 `pause`，做完才 `done`。
 
-## 參考產品（REA）
-banner 的 `[rea]` 行說明 REA 是否可用：用戶提到想參考某產品的功能時，可用就提議用 REA 分析；沒裝就提示一次 `npx rea-agents setup`，用戶說不要就照 `[rea]` 行的 decline 指令記下來。範圍見 RULES.md 的 REA 一節。
+## 參考產品（REA）與學習教訓
+- banner `[rea]` 行：用戶提到參考產品時，有 REA 就提議分析，沒有就提示一次 `npx rea-agents setup`（範圍見 RULES.md 的 REA）。
+- 用戶糾正/重複指示、推翻決定、或驗證抓到失敗時，自動寫教訓並在回報點名一行：`node "${CLAUDE_PLUGIN_ROOT}/hooks/core-resolve.js" .specialist/tools/lessons.js add --scope user|project --type pref|fact|pitfall|check --text "..."`（規則見 RULES.md 的 Lessons）。
 
-需要更多規則時（用戶授權自主、派工前、合併前、提到參考產品時）讀 `${CLAUDE_PLUGIN_ROOT}/../../.specialist/Ansuz/RULES.md`。
+需要更多規則時（授權自主、派工前、合併前、參考產品、寫教訓）讀 `${CLAUDE_PLUGIN_ROOT}/../../.specialist/Ansuz/RULES.md`。

package/core/plugins/kenaz/scripts/kenaz.test.js

@@ -59,7 +59,7 @@ test('ygg status fixture: masked key, room, peers, mail (TASK_2366)', () => {
   const s = buildStatus(
     { enabled: true, effective_project_key: 'acme/app', node_name: 'laptop', publishable_key: key, key_source: 'project', collaboration_projects: ['acme/app'] },
     { connected: true, nodes: [{ node_name: 'laptop', is_online: true, updated_at: new Date().toISOString() }, { node_name: 'desk', is_online: true, updated_at: new Date().toISOString() }, { node_name: 'old', is_online: false }, { node_name: 'BA-Cheng', is_online: true, updated_at: '2026-06-30T00:00:00Z' }] },
-    { pending_count: 2, undeliverable_count: 1 });
+    { pending_count: 2, waiting_count: 2, undeliverable_count: 1 });
   const out = renderStatus(s);
   assert.ok(!out.includes('SECRETSECRET') && !JSON.stringify(s).includes('SECRETSECRET'));
   assert.match(out, /ygk_\*{4}1234 \(source: project\)/);
@@ -67,6 +67,7 @@ test('ygg status fixture: masked key, room, peers, mail (TASK_2366)', () => {
   assert.match(out, /Relay:\s+connected/);
   assert.match(out, /Peers online:\s+desk$/m);
   assert.match(out, /Pending mail:\s+2/);
+  assert.match(out, /Waiting for a session: 2/);
   assert.match(out, /Undeliverable:\s+1/);
   const down = renderStatus(buildStatus({ enabled: false }, { connected: false, reason: 'relay unreachable', nodes: [] }, null));
   assert.match(down, /NOT connected \(relay unreachable\)/);

package/core/plugins/kenaz/scripts/ygg.js

@@ -73,6 +73,7 @@ function buildStatus(cfg, relay, peer) {
       ? 'Room "' + cfg.effective_project_key + '" is a generic name; ' + online.join(', ') + ' may be an unrelated project. For a private room set yggdrasil_project: "' + cfg.effective_project_key + '-<unique-id>" in .kenaz/yggdrasil.yaml.'
       : '',
     pending_mail: peer && typeof peer.pending_count === 'number' ? peer.pending_count : null,
+    waiting_mail: peer && typeof peer.waiting_count === 'number' ? peer.waiting_count : null,
     undeliverable_mail: peer && typeof peer.undeliverable_count === 'number' ? peer.undeliverable_count : null,
     // TASK_2380: real delivery mode per live session (push | pull-on-prompt | none), never a bare 'enabled'.
     delivery_mode: peer && peer.delivery_mode ? peer.delivery_mode : 'unknown',
@@ -92,6 +93,7 @@ function renderStatus(s) {
     'Relay:            ' + (s.relay_connected ? 'connected' : 'NOT connected' + (s.relay_note ? ' (' + s.relay_note + ')' : '')),
     'Peers online:     ' + (s.peers_online.length ? s.peers_online.join(', ') : 'none'),
     'Pending mail:     ' + (s.pending_mail == null ? 'unknown' : s.pending_mail),
+    'Waiting for a session: ' + (s.waiting_mail == null ? 'unknown' : s.waiting_mail) + ' (stored on this node, readable)',
     'Undeliverable:    ' + (s.undeliverable_mail == null ? 'unknown' : s.undeliverable_mail),
     'Delivery:         ' + s.delivery_mode + (s.sessions.length ? '' : ' (no live sessions)'),
   ];

package/core/plugins/kenaz/skills/code_reviewer/SKILL.md

@@ -232,7 +232,6 @@ description: 程式碼審查、三級問題分類（Blocker/Suggestion/Nit）、
 
 | Mutation | Counterpart | 缺失嚴重度 |
 |----------|-------------|-----------|
-| `hippocampus_episode_start` | `hippocampus_episode_close` | leak（episode 永不歸檔） |
 | `task-api.js claim` | `task-api.js complete` 或 `move blocked` | orphan（task 卡在 active/） |
 | `addEventListener` | `removeEventListener` | leak（listener 記憶體洩漏） |
 | `setInterval` | `clearInterval` | leak（定時器持續觸發） |

package/core/plugins/kenaz/skills/code_reviewer/patterns.yaml

@@ -17,14 +17,6 @@ mutation_counterpart:
   #   orphan = logical state / lifecycle not terminated
 
   pairs:
-    - pair: hippocampus_episode
-      mutation: 'hippocampus_episode_start'
-      counterpart: 'hippocampus_episode_close'
-      severity: leak
-      rationale: 'episode never closed -> consolidation never fires, unarchived memory accumulates'
-      grep_mutation: 'hippocampus_episode_start'
-      grep_counterpart: 'hippocampus_episode_close'
-
     - pair: task_lifecycle
       mutation: 'task-api.js claim'
       counterpart: 'task-api.js complete | task-api.js move'

package/core/plugins/kenaz/skills/dev_agent/SKILL.md

@@ -256,8 +256,6 @@ description: 開發協調、Pipeline管理、任務執行、進度追蹤、Agent
 | `kenaz_lsp_references` | 所有引用 / 修改影響範圍 | 修改前評估 blast radius |
 | `kenaz_lsp_definition` | 定義位置 | 跳到宣告處 |
 | `kenaz_lsp_symbols` | 檔案內 symbol 列表 | 了解檔案結構 |
-| `synapse_recall` | 歷史 rune / 已知風險 | 修改前召回 |
-| `synapse_status` | 記憶系統狀態 | 任務開始前檢查 |
 
 文字與概念搜尋用 Grep / Glob。
 
@@ -281,8 +279,7 @@ description: 開發協調、Pipeline管理、任務執行、進度追蹤、Agent
 **在開始任何開發任務前，建議執行：**
 
 1. **獲取專案 Context**：
-   - 使用 `synapse_status` 了解記憶系統狀態
-   - 使用 `synapse_recall` 召回相關已知風險與決策
+   - 讀取任務卡與 `kenaz learn list` 的相關教訓
 
 2. **搜索相關代碼**：
    - 使用 Grep / Glob 找到相關實現
@@ -335,10 +332,10 @@ description: 開發協調、Pipeline管理、任務執行、進度追蹤、Agent
 2. 重新讀取 Skill 文件
 3. 如果問題持續，直接應用該 Agent 的核心職責邏輯
 
-### LSP / Synapse 查詢失敗時
+### LSP 查詢失敗時
 1. 繼續執行任務（降級為 Grep/Glob）
 2. 確認 Dashboard 已啟動（依賴 Rust HTTP server on port 18080）
-3. 使用 `synapse_status` 檢查記憶系統狀態
+3. 使用 `kenaz_ping` 檢查服務狀態
 
 ---
 

package/lib/cli.js

@@ -14,7 +14,7 @@ const dash = require('./dashboard');
 const PKG_ROOT = path.resolve(__dirname, '..');
 const PKG = require('../package.json');
 const MIN_NODE = 18;
-const USAGE = 'usage: kenaz <install|uninstall|status|doctor|init|ygg join <key>|ygg status|ygg leave|alaya status|alaya register|model [set <id>|unset] [--rigor r]> [--dry-run] [--home <dir>] [--no-service] [--no-claude] [--no-codex] [--keep-dashboard] [--server-bin <path>]';
+const USAGE = 'usage: kenaz <install|uninstall|status|doctor|init|ygg join <key>|ygg status|ygg leave|alaya status|alaya register|model [set <id>|unset] [--rigor r]|stats [--days N] [--json]|learn <add|list|rm>> [--dry-run] [--home <dir>] [--no-service] [--no-claude] [--no-codex] [--keep-dashboard] [--server-bin <path>]';
 
 function parseArgs(argv) {
   const o = { cmd: argv[0], flags: {} };
@@ -41,7 +41,9 @@ function coreModule(p, ...rel) {
   return null;
 }
 const reaDetect = (p) => coreModule(p, '.specialist', 'tools', 'rea-detect.js');
+const lessons = (p) => coreModule(p, '.specialist', 'tools', 'lessons.js');
 const dispatchModel = (p) => coreModule(p, '.formation', 'tools', 'dispatch-model.js');
+const kenazStats = (p) => coreModule(p, '.formation', 'tools', 'kenaz-stats.js');
 
 function paths(home) {
   const dir = path.join(home, '.kenaz');
@@ -232,8 +234,6 @@ async function doctor(p, flags, out, deps = {}) {
   const r = await probe(process.env.KENAZ_HTTP_PORT || '18080');
   let ver = ''; try { ver = JSON.parse(r.body).version; } catch (_) { /* health body is optional */ }
   add('server reachable', r.ok ? 'ok' : 'FAIL', r.detail + (ver ? `, version ${ver}` : ''));
-  // TASK_2390: memory is frozen in the CLI build; 'disabled' is the expected state, never a failure.
-  if (r.ok) { let emb = ''; try { emb = JSON.parse(r.body).embedding || ''; } catch (_) { /* optional */ } add('memory', 'ok', emb === 'disabled' || !emb ? 'disabled (set KENAZ_MEMORY=on to enable)' : `on, embedding ${emb}`); }
 
   const d = dash.detect(p.home, deps.dashboard);
   if (!d.installed) add('dashboard', 'skip', 'no Kenaz Dashboard on this machine');
@@ -338,6 +338,16 @@ function run(argv, out = console.log, deps = {}) {
     if (!dm) { out('kenaz-core not installed: run `kenaz install`'); return 1; }
     return dm.main(argv.slice(1), out);
   }
+  if (argv[0] === 'stats') {
+    const ks = kenazStats(paths(os.homedir()));
+    if (!ks) { out('kenaz-core not installed: run `kenaz install`'); return 1; }
+    return ks.main(argv.slice(1), out);
+  }
+  if (argv[0] === 'learn') {
+    const lm = lessons(paths(os.homedir()));
+    if (!lm) { out('kenaz-core not installed: run `kenaz install`'); return 1; }
+    return lm.main(argv.slice(1), out);
+  }
   if (argv[0] === 'ygg' || argv[0] === 'init') return passthrough(argv, deps);
   const { cmd, flags } = parseArgs(argv);
   const fn = { install, uninstall, status, doctor }[cmd];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kenaz",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "description": "Install Kenaz (plugin, hooks, kenaz-server) for Claude Code and Codex: npx kenaz install",
   "bin": {
     "kenaz": "bin/kenaz.js"
@@ -20,11 +20,11 @@
     "test": "node --test lib/cli.test.js"
   },
   "optionalDependencies": {
-    "@kenazai/server-darwin-arm64": "0.3.9",
-    "@kenazai/server-darwin-x64": "0.3.9",
-    "@kenazai/server-linux-arm64": "0.3.9",
-    "@kenazai/server-linux-x64": "0.3.9",
-    "@kenazai/server-win32-x64": "0.3.9"
+    "@kenazai/server-darwin-arm64": "0.3.11",
+    "@kenazai/server-darwin-x64": "0.3.11",
+    "@kenazai/server-linux-arm64": "0.3.11",
+    "@kenazai/server-linux-x64": "0.3.11",
+    "@kenazai/server-win32-x64": "0.3.11"
   },
   "license": "UNLICENSED",
   "repository": {

package/core/.claude/hooks/handoff-snapshot-on-decision.js

@@ -1,188 +0,0 @@
-#!/usr/bin/env node
-/**
- * handoff-snapshot-on-decision.js — PostToolUse hook for synapse_inscribe (TASK_1400)
- *
- * Fires after mcp__kenaz-dashboard__synapse_inscribe when the inscribed rune type
- * is one of: decision, risk, ash. Insight/pattern/fix/summary inscribes do NOT
- * fire (too noisy). Includes rune_id in the nudge.
- * 5-minute dedup keyed on rune_id (or normalized content hash if rune_id absent).
- *
- * Matcher: mcp__kenaz-dashboard__synapse_inscribe
- */
-'use strict';
-try { require('./_dedupe-guard').guard(typeof __filename === 'string' ? __filename : null); } catch (_) { /* never block a hook on guard load failure (e.g. vm sandbox without __filename) */ }
-const kenazProjectRoot = require('./_project-guard').guard();
-
-const fs = require('fs');
-const path = require('path');
-const { fenceSignal } = require('./_signal-fence');
-
-const PROJECT_DIR = kenazProjectRoot;
-const TELEMETRY_PATH = path.join(
-  PROJECT_DIR,
-  '.kenaz', 'specialist', 'handoff_nudges.jsonl'
-);
-const DEDUP_WINDOW_MS = 5 * 60 * 1000;
-const DEDUP_KEY_PREFIX = 'inscribe:';
-
-// Only these rune types trigger the nudge
-const TRIGGER_TYPES = new Set(['decision', 'risk', 'ash']);
-
-function readStdin() {
-  try {
-    return JSON.parse(fs.readFileSync(0, 'utf8').trim() || '{}');
-  } catch {
-    return {};
-  }
-}
-
-function extractInscribeType(payload) {
-  // Type can be in tool_input or inferred from response
-  return (
-    payload?.tool_input?.type ||
-    payload?.toolInput?.type ||
-    null
-  );
-}
-
-function extractRuneId(payload) {
-  // rune_id appears in the tool_response from synapse_inscribe
-  try {
-    const resp =
-      payload?.tool_response ||
-      payload?.tool_result;
-    if (!resp) return null;
-
-    // Attempt to parse text content as JSON
-    let text = '';
-    if (typeof resp === 'string') {
-      text = resp;
-    } else if (resp?.content && Array.isArray(resp.content)) {
-      text = resp.content.map(c => c?.text || '').join('');
-    } else if (typeof resp === 'object') {
-      text = JSON.stringify(resp);
-    }
-
-    // Try JSON parse first
-    try {
-      const parsed = JSON.parse(text);
-      if (parsed?.rune_id) return parsed.rune_id;
-      if (parsed?.id) return parsed.id;
-    } catch { /* not JSON */ }
-
-    // Fallback: regex extract
-    const m = text.match(/"rune_id"\s*:\s*"([^"]+)"/);
-    if (m) return m[1];
-    const m2 = text.match(/"id"\s*:\s*"([^"]+)"/);
-    if (m2) return m2[1];
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-function normalizeKey(runeId, type, content) {
-  if (runeId) return runeId;
-  // Fallback: hash of type+content snippet
-  const snippet = `${type}:${(content || '').substring(0, 40)}`;
-  return snippet.replace(/\s+/g, '_');
-}
-
-function isDeduped(key) {
-  try {
-    if (!fs.existsSync(TELEMETRY_PATH)) return false;
-    const lines = fs.readFileSync(TELEMETRY_PATH, 'utf8').split(/\r?\n/).filter(Boolean);
-    const cutoff = Date.now() - DEDUP_WINDOW_MS;
-    for (let i = lines.length - 1; i >= 0; i--) {
-      let entry;
-      try { entry = JSON.parse(lines[i]); } catch { continue; }
-      const ts = Number(entry.timestamp_ms || 0);
-      if (ts && ts < cutoff) break;
-      if (entry.dedup_key === key && !entry.suppressed) return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-
-function appendTelemetry(record) {
-  try {
-    fs.mkdirSync(path.dirname(TELEMETRY_PATH), { recursive: true });
-    fs.appendFileSync(TELEMETRY_PATH, JSON.stringify(record) + '\n', 'utf8');
-  } catch { /* best-effort */ }
-}
-
-// Auto-invoke the snapshot CLI as a detached process so the hook returns fast
-// and the snapshot write does not depend on the agent remembering. Errors are
-// swallowed — never block the user turn.
-function invokeHandoffSnapshot(trigger, milestone, sessionId, transcriptPath) {
-  try {
-    const { spawn } = require('child_process');
-    const cli = path.join(PROJECT_DIR, '.specialist', 'Ansuz', 'tools', 'ansuz-handoff-snapshot.js');
-    if (!fs.existsSync(cli)) return;
-    const args = [cli, `--trigger=${trigger}`];
-    if (milestone) args.push(`--last-milestone=${milestone}`);
-    if (sessionId) args.push(`--session-id=${sessionId}`);
-    // Scopes pending/unfinished to tasks this conversation touched.
-    if (transcriptPath) args.push(`--transcript-path=${transcriptPath}`);
-    const child = spawn('node', args, {
-      detached: true,
-      stdio: 'ignore',
-      cwd: PROJECT_DIR,
-      windowsHide: true,
-    });
-    child.unref();
-  } catch { /* best-effort */ }
-}
-
-function main() {
-  const payload = readStdin();
-  const inscribeType = extractInscribeType(payload);
-
-  // Only fire for decision/risk/ash types
-  if (!inscribeType || !TRIGGER_TYPES.has(inscribeType)) {
-    process.exit(0);
-  }
-
-  // Ansuz-only: see handoff-snapshot-on-commit.js.
-  if (!require('./_ansuz-conversation').isAnsuzConversation(payload.transcript_path, PROJECT_DIR)) {
-    process.exit(0);
-  }
-
-  const runeId = extractRuneId(payload);
-  const content = payload?.tool_input?.content || payload?.toolInput?.content || '';
-  const dedupKey = DEDUP_KEY_PREFIX + normalizeKey(runeId, inscribeType, content);
-  const suppressed = isDeduped(dedupKey);
-
-  appendTelemetry({
-    timestamp: new Date().toISOString(),
-    timestamp_ms: Date.now(),
-    hook: 'handoff-snapshot-on-decision',
-    dedup_key: dedupKey,
-    inscribe_type: inscribeType,
-    rune_id: runeId,
-    suppressed,
-  });
-
-  if (suppressed) {
-    process.exit(0);
-  }
-
-  const runeRef = runeId ? ` (rune_id: ${runeId})` : '';
-
-  // Auto-write the handoff (system-level enforcement, instance-independent).
-  // TASK_1837: pass NO --last-milestone. The old value ('<type> rune inscribed')
-  // carried zero information and became the slot's current_topic, clobbering the
-  // real work topic (measured 2026-07-31: 5 of 8 orphan slots had it as topic —
-  // garbage inherited by the next session). With no milestone the snapshot CLI
-  // derives the topic from the latest commit subject: actual work content. The
-  // rune reference stays in the stdout nudge below, where it is useful.
-  invokeHandoffSnapshot('live_decision_point', null, payload.session_id, payload.transcript_path);
-
-  process.stdout.write(
-    '\n' + fenceSignal('handoff', `🔁 ${inscribeType} rune inscribed${runeRef}. Handoff auto-snapshot dispatched (live_decision_point).`) + '\n'
-  );
-}
-
-main();