kenaz 0.3.9 → 0.3.11

package/core/.claude/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 .formation/tools/dispatch.js --skill=do --task=TASK_XXX --dispatch-mode=subagent`（加 `--project-path`；Codex 加 `--harness=codex`）。把輸出 JSON 的 `promptText` 交給 subagent，`agentParams` 照用（模型不要自己換）。
+  2. 產生派工內容：`node .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 .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 .specialist/tools/autonomy.js grant --session <id> --scope "<授權範圍>"`，再讀 RULES.md 的 Autonomy 一節。之後 Turn Context 會顯示 `[autonomy] ON`，結束回合會被 Stop hook 擋回：自己決定、一路做完，不在回合結尾問「要我…嗎？」；只有 RULES.md 列的必要停點才 `pause`，做完才 `done`。
+用戶明確授權自主時：立刻 `node .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 .specialist/tools/lessons.js add --scope user|project --type pref|fact|pitfall|check --text "..."`（規則見 RULES.md 的 Lessons）。
 
-需要更多規則時（用戶授權自主、派工前、合併前、提到參考產品時）讀 `.specialist/Ansuz/RULES.md`。
+需要更多規則時（授權自主、派工前、合併前、參考產品、寫教訓）讀 `.specialist/Ansuz/RULES.md`。

package/core/.claude/hooks/memory-guard.js

@@ -88,11 +88,18 @@ function activeKnowledgeDir(projectDir) {
   }
 }
 
+/** ~/.kenaz/knowledge: the user-preference layer written by `kenaz learn --scope user` (local, never synced). */
+function userKnowledgeDir() {
+  const home = process.env.HOME || process.env.USERPROFILE;
+  return home ? path.join(home, '.kenaz', 'knowledge') : path.join(PROJECT_DIR, '.kenaz', 'knowledge');
+}
+
 function defaultSourceDirs(projectDir) {
   const dirs = [];
   const memDir = defaultMemoryDir(projectDir);
   if (memDir) dirs.push(memDir);
   dirs.push(activeKnowledgeDir(projectDir));
+  dirs.push(userKnowledgeDir()); // TASK_2409: lessons that apply to every project of this user
   return dirs;
 }
 
@@ -433,6 +440,10 @@ function match(toolName, toolInput, options) {
       { kind: 'guard', file: r.file, sessionId: options.sessionId },
       { projectDir, usageLogPath: options.usageLogPath, logUsage: options.logUsage },
     );
+    // TASK_2409: user-layer lessons keep their fire stats next to the lesson (`kenaz learn list`).
+    if (options.sessionId && path.dirname(r.absPath) === userKnowledgeDir()) {
+      appendUsageLog({ kind: 'guard', file: r.file, sessionId: options.sessionId }, { usageLogPath: path.join(userKnowledgeDir(), '.usage.jsonl') });
+    }
   }
   return results;
 }
@@ -703,6 +714,8 @@ function main() {
 
 module.exports = {
   loadTriggers,
+  compileTrigger,
+  userKnowledgeDir,
   match,
   formatGuardLines,
   stripHeredocBodies,

package/core/.claude/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/.claude/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/.claude/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/core/.claude/skills/heimdall/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: Heimdall
-description: 代碼疆域守望者 — git 驅動的代碼健康審查（kenaz_lsp_callers + synapse_recall），生成 OptimizationProposal；記憶健康僅記錄趨勢，不做 KEEP/REVERT
+description: 代碼疆域守望者 — git 驅動的代碼健康審查（kenaz_lsp_callers），生成 OptimizationProposal；記憶健康僅記錄趨勢，不做 KEEP/REVERT
 ---
 
 # Heimdall ᚺ — 守望者
@@ -39,17 +39,16 @@ trigger=manual target_symbol=<SYMBOL> project_path=<PATH>
 
 ### Attention Trigger
 
-`trigger=attention`（舊的注意力聚合工具已移除）：改以 git 近期變更檔 + 已知 rune 作為調查起點。
+`trigger=attention`（舊的注意力聚合工具已移除）：改以 git 近期變更檔 + 作為調查起點。
 
 1. **取得焦點**：`git log --since=7.days --name-only` 統計最常被修改的檔案（top 15）→ `kenaz_lsp_symbols(file)` 取得其中的 symbols
 2. **深度調查每個 symbol**：
    - `kenaz_lsp_references(symbol, depth=2)` → 爆炸半徑
-   - `synapse_recall(query=symbol)` → 已知風險/歷史 rune
    - `kenaz_lsp_callers(symbol)` → 呼叫者
-3. **交叉比對**：合成 blast_radius + known_risks + callers → 產生 finding
-4. **嚴重性分級**：references >= 20 或有未修復 risk rune → HIGH，>= 8 → MEDIUM，else → LOW
+3. **交叉比對**：合成 blast_radius + callers → 產生 finding
+4. **嚴重性分級**：references >= 20 → HIGH，>= 8 → MEDIUM，else → LOW
 5. **空結果**：若無近期變更焦點 → 輸出 `ᚺ Heimdall: clean scan. No attention signals.` 並結束
-6. **降級**：LSP 不可用 → 降級到 `scheduled_trigger` 流程（Grep/Glob + synapse_recall）
+6. **降級**：LSP 不可用 → 降級到 `scheduled_trigger` 流程（Grep/Glob）
 
 ---
 

package/core/.claude/skills/huginn/SKILL.md

@@ -25,58 +25,40 @@ Converting an advisory into a task is **Ansuz exclusive decision**, and Ansuz MU
 
 1. Parse context block: `trigger`, `project_path`, `focus` (optional), `query` (optional)
 2. Confirm `project_path` is set -- abort if missing
-3. Call `synapse_status({ projectPath: project_path })` -- if unavailable, output:
-   `Huginn: Synapse unavailable. Cannot think without perception. Abort.` and exit
+3. (memory probe removed in TASK_2411 -- Huginn perceives code, tasks, Heimdall and wishes only)
 4. **Read loop mode** -- read `{project_path}/.kenaz/loop/loop.json` (fallback: `.kenaz/loop.json`, then `.collaboration/loop.json`).
-   Canonical writer: `readLoopConfig` in `.formation/tools/post-complete/health.js:28`.
    If no file found, default to `{ mode: "manual" }`.
    Store as `loop_mode` ("manual" | "auto"). Loop mode read is harmless; output routing is identical for both branches -- advisory file only.
 5. **Sanity cap** -- no quota API call needed. Huginn targets <= 5 advisories per run (quality cap, not a hard abort).
-6. Output: `trigger_type`, `loop_mode`, `synapse_available`
+6. Output: `trigger_type`, `loop_mode`
 
 ---
 
 ## Phase 1 - Perceive (parallel data collection)
 
-Collect raw signals from 7 sources. All MCP calls MUST include `projectPath`.
+Collect raw signals from 5 sources. All MCP calls MUST include `projectPath`.
 
 ### 1a. Code Perception
 git log hot files (last 14 days), Grep for TODO/FIXME/HACK, kenaz_lsp_references on the top hot symbols
 Output: graph_signals (name kept for downstream phases)
 
-### 1b. Cognitive Perception
-synapse_recall, synapse_sigils
-- **COGNITIVE DEBT pre-emption**: For each hot symbol from 1a with zero runes returned by synapse_recall AND a high kenaz_lsp_references count:
-  tag it as COGNITIVE DEBT in cognitive_signals. In Phase 4, draft an insight rune at confidence 0.5
-  for the top-1 COGNITIVE DEBT symbol (draft only). Do NOT re-propose these symbols if they appear in
-  `.kenaz/huginn-proposed-symbols.json` within the last 30 days (see Phase 3 Repeat Guard).
-Output: cognitive_signals
-
-### 1c. Episodic Perception
-hippocampus_episode_recall difficulties, hippocampus_episode_recall successes
-Output: episodic_signals
-
-### 1d. Cross-Project Perception (if Cortex available)
-cortex_recall architecture patterns
-Output: cross_project_signals
-
-### 1e. Task Perception
+### 1b. Task Perception
 - Read .kenaz/tasks/done/ or .collaboration/tasks/done/ last 30 days
 - Read blocked tasks
 - Cluster by scope_paths
 Output: task_signals
 
-### 1f. Heimdall Perception
+### 1c. Heimdall Perception
 - **Health snapshots**: `Bash: ls -t {project_path}/.kenaz/health_snapshots/*_after.json 2>/dev/null | head -5`
   - Read each JSON -> extract `score`, `sub_metrics`, `delta`
-- **Health trend**: post-complete only records memory health (`post_complete_verdict: RECORDED`, never reverts). Use the `score` / `delta` series from the snapshots above to spot a declining trend; a falling score points at memory-store hygiene (stale runes, episode backlog), not at the task's code.
+- **Health trend**: post-complete only records memory health (`post_complete_verdict: RECORDED`, never reverts). Use the `score` / `delta` series from the snapshots above to spot a declining trend; a falling score is a memory-store signal, not a code signal.
 - **OptimizationProposals**: `Bash: curl -s "http://127.0.0.1:18080/api/proposals/list?projectPath={project_path}&status=pending" 2>/dev/null`
   - Each proposal becomes a finding with `source: "heimdall"` -- Huginn should refine + prioritize alongside other signals
   - Dismiss processed proposals via /ignore endpoint (permanently dismissed, no task created).
   - If no verdict yet, skip marking -- GC auto-expires Huginn-generated pending proposals after 30 days.
 Output: heimdall_signals: { health_trend, optimization_proposals[] }
 
-### 1g. Wish Perception
+### 1d. Wish Perception
 - Fetch pending wishes: `Bash: curl -s http://127.0.0.1:18080/api/wishes/list?status=pending&project_path={project_path}`
 - If pending wishes exist:
   - Mark each as picked_up via `PUT /api/wishes/{id}`
@@ -155,7 +137,7 @@ Each finding is appended as one JSON line (JSONL format, English only -- MEM-LAN
 - `ts` -- ISO8601 timestamp of this Huginn run
 - `title` -- < 80 chars, English, descriptive; no "Create task" / "Open PR" phrasing
 - `insight` -- What was observed and why it matters (1-2 sentences, English)
-- `evidence` -- `{ sources: [tool_name,...], runes: [rune_id,...], metrics: {} }`
+- `evidence` -- `{ sources: [tool_name,...], metrics: {} }`
 - `confidence` -- 0.0-1.0 from scoring step
 - `source_signals` -- array of signal categories that contributed
 - `status` -- always "unread" on write; Ansuz sets to "read" / "converted" / "dismissed"
@@ -169,18 +151,9 @@ Example line (compact, one object per line):
 
 **Rotation rule (bounded file)**: On every write, the combined array of existing + new entries is sliced to the 100 most recent entries (`.slice(-100)`) before writing back. This keeps the file bounded at <= 100 lines regardless of run frequency. File size stays under ~200 KB under normal operation. Huginn itself performs the rotation inline -- no external cron needed.
 
-## Phase 4 - Inscribe (cognitive persistence)
+## Phase 4 - Record
 
-For each accepted finding involved symbols:
-  - synapse_recall to check existing runes
-  - synapse_inscribe type=insight, confidence >= 0.7
-
-If 3+ symbols form unnamed concept: synapse_forge Sigil
-
-Rules:
-- English only (MEM-LANG-001)
-- confidence >= 0.7 (higher than standard 0.6 -- derived knowledge)
-- Do NOT inscribe every finding -- only long-term value
+Huginn is advisory-only: findings go to the advisory file (Phase 3). Durable lessons are recorded by Ansuz with `kenaz learn add`; Huginn does not write memory.
 
 ---
 
@@ -193,7 +166,7 @@ Output session report (<= 20 lines):
   Trigger:   {scheduled | milestone | manual}
   Loop Mode: {manual | auto}
   Duration:  {thinking time}
-  Sources:   synapse: OK/FAIL, hippocampus: OK/FAIL, cortex: OK/FAIL, tasks: OK
+  Sources:   code: OK/FAIL, tasks: OK/FAIL, heimdall: OK/FAIL, wishes: OK/FAIL
 
   Advisories written: {N} (file: .kenaz/specialist/huginn_advisory.jsonl)
   Drafts skipped: {N}

package/core/.collaboration/core/task-api.js

@@ -170,101 +170,6 @@ function releaseClaimMarker(taskId, projectRoot) {
   try { require('fs').unlinkSync(markerPath); } catch { /* already gone */ }
 }
 
-// ─────────────────────────────────────────
-// TASK_1861: Dispatch-path-agnostic health snapshot capture
-// _before at activation (move/claim/update→active), _after + observe-only verdict
-// at completion (complete AND bare `move X done`). Fires a detached child so the
-// short-lived CLI never blocks, fails, or slows on Dashboard state. Every capture
-// attempt is audited in .kenaz/health_snapshots/snapshot_events.jsonl (never silent).
-// Reuses .formation/tools/post-complete/health.js (measureHealthScoreSync etc.) —
-// no third implementation. Does NOT touch guardian_counter.json (TASK_1720 periodic
-// counter semantics unchanged; verdict stays observe-only, no git action).
-// ─────────────────────────────────────────
-
-function _appendSnapshotEvent(projectRoot, taskId, phase, action, reason) {
-  try {
-    const dir = path.join(projectRoot, '.kenaz', 'health_snapshots');
-    fsSync.mkdirSync(dir, { recursive: true });
-    const line = JSON.stringify({
-      task_id: taskId,
-      ts: new Date().toISOString(),
-      snapshot_type: phase,
-      action,
-      ...(reason ? { reason } : {}),
-    });
-    fsSync.appendFileSync(path.join(dir, 'snapshot_events.jsonl'), line + '\n', 'utf8');
-  } catch { /* audit is best-effort — must never block task ops */ }
-}
-
-function scheduleHealthSnapshotCapture(taskId, phase, projectRoot) {
-  try {
-    if (!taskId || !projectRoot) return;
-    const healthJs = path.join(__dirname, '..', '..', '.formation', 'tools', 'post-complete', 'health.js');
-    if (!fsSync.existsSync(healthJs)) {
-      _appendSnapshotEvent(projectRoot, taskId, phase, 'skipped', 'health_module_missing');
-      return;
-    }
-    const cfg = { taskId, phase, projectRoot, healthJs };
-    // ASCII-only inline script (Windows argv codepage safety). Child owns the full
-    // outcome audit: written | skipped(reason). measureHealthScoreSync already
-    // handles Dashboard-down gracefully (returns null within its own timeout).
-    const script = [
-      `const CFG = ${JSON.stringify(cfg)};`,
-      "const fs = require('fs');",
-      "const path = require('path');",
-      "function logEvent(action, reason) {",
-      "  try {",
-      "    const dir = path.join(CFG.projectRoot, '.kenaz', 'health_snapshots');",
-      "    fs.mkdirSync(dir, { recursive: true });",
-      "    const line = JSON.stringify({ task_id: CFG.taskId, ts: new Date().toISOString(), snapshot_type: CFG.phase, action, ...(reason ? { reason } : {}) });",
-      "    fs.appendFileSync(path.join(dir, 'snapshot_events.jsonl'), line + '\\n', 'utf8');",
-      "  } catch (_e) { /* best-effort */ }",
-      "}",
-      "try {",
-      "  const snapFile = path.join(CFG.projectRoot, '.kenaz', 'health_snapshots', CFG.taskId + '_' + CFG.phase + '.json');",
-      "  if (fs.existsSync(snapFile)) { logEvent('skipped', 'snapshot_already_exists'); process.exit(0); }",
-      "  const h = require(CFG.healthJs);",
-      "  const health = h.measureHealthScoreSync(CFG.projectRoot);",
-      "  if (!health || typeof health.score !== 'number') { logEvent('skipped', 'dashboard_unreachable'); process.exit(0); }",
-      // TASK_1891: capture the written payload (delta_from_previous) for
-      // observability threading into computeHealthVerdict below -- see
-      // health.js's computeHealthVerdict doc comment for why that field
-      // never gates the verdict itself.
-      "  const afterPayload = h.saveTaskHealthSnapshot(CFG.taskId, CFG.phase, health, CFG.projectRoot);",
-      "  logEvent('written');",
-      "  if (CFG.phase === 'after') {",
-      "    const pre = h.readPreTaskHealthSnapshot(CFG.taskId, CFG.projectRoot);",
-      "    if (pre && typeof pre.score === 'number') {",
-      "      const loopCfg = h.readLoopConfig(CFG.projectRoot);",
-      "      const threshold = typeof loopCfg.revert_threshold === 'number' ? loopCfg.revert_threshold : h.DEFAULT_REVERT_THRESHOLD;",
-      // TASK_1890/1891: same computeHealthVerdict as post-complete.js's
-      // auto/manual arms -- no third re-implementation of the delta/trust-gate
-      // logic. No git access here (no isScopeUnchanged callback), so guard 3
-      // (stale snapshot + zero scope diff) is a safe no-op for this call
-      // site, same as it always was before TASK_1890. TASK_1891: pass the
-      // full `pre` object (not pre.score) so ordering + symmetric trust can
-      // be checked -- this is one of the two call sites that actually runs
-      // in production (readLoopConfig's TASK_1885 note).
-      "      const vr = h.computeHealthVerdict(pre, health, threshold, { projectPath: CFG.projectRoot, trendDeltaFromPrevious: afterPayload ? afterPayload.delta_from_previous : null });",
-      "      const reason = vr.verdict === 'REVERT'",
-      "        ? vr.reason + ' - observe-only capture at task completion, no git action taken'",
-      "        : vr.reason;",
-      "      h.writeVerdictToTask(CFG.taskId, vr.verdict, vr.delta, reason, CFG.projectRoot);",
-      "    }",
-      "  }",
-      "} catch (e) { logEvent('skipped', 'error: ' + String(e && e.message || e)); }",
-    ].join('\n');
-    const { spawn } = require('child_process');
-    const child = spawn(process.execPath, ['-e', script], {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true,
-    });
-    child.unref();
-  } catch (e) {
-    _appendSnapshotEvent(projectRoot, taskId, phase, 'skipped', 'spawn_failed: ' + String(e && e.message || e));
-  }
-}
 const yaml = (() => {
   try { return require('js-yaml'); } catch {
     // Fallback: resolve .vendor/js-yaml.cjs relative to this script's real location.
@@ -1770,9 +1675,7 @@ class TaskAPI {
    */
   async moveTask(taskId, newStatus, taskData = null, options = {}) {
     await this._ensureStatusDirs();
-    // TASK_2264: skipHealthAfter = the caller (completeTask) knows post-complete will measure and
-    // save the 'after' snapshot itself, so scheduling a second detached measurement is pure waste.
-    const { skipValidation = false, forceClaim = false, skipHealthAfter = false } = options;
+    const { skipValidation = false, forceClaim = false } = options;
 
     // 取得任務資料
     let task = taskData;
@@ -1919,20 +1822,6 @@ class TaskAPI {
       releaseClaimMarker(taskId, _projectRootForClaim);
     }
 
-    // TASK_1861: dispatch-path-agnostic health capture. moveTask is the single choke
-    // point every activation/completion path funnels through (claim → moveTask,
-    // update --status → moveTask, complete → moveTask, bare move). Fire-and-forget
-    // detached child; idempotent only against snapshots that ALREADY exist when the child
-    // starts (it can race a concurrent writer). TASK_2264: completeTask therefore passes
-    // skipHealthAfter when its own in-process postComplete will measure 'after', so that
-    // path is measured exactly once; paths with no post-complete (bare move, update --status,
-    // complete --skip-post-complete) keep this capture as their only one.
-    if (targetDir === 'active') {
-      scheduleHealthSnapshotCapture(taskId, 'before', _projectRootForClaim);
-    } else if (targetDir === 'done' && !skipHealthAfter) {
-      scheduleHealthSnapshotCapture(taskId, 'after', _projectRootForClaim);
-    }
-
     // Yggdrasil: sync status change to kenaz_tasks
     const sync = getTaskSync();
     if (sync) {
@@ -2126,13 +2015,8 @@ class TaskAPI {
       updatedTask.actual_hours = options.actual_hours;
     }
 
-    // TASK_2264: decide up front whether post-complete (below) will measure 'after' in-process.
-    // TASK_2288 single-winner rule: whenever a post-complete run is expected for this completion,
-    // post-complete's own measurement is the ONE 'after' capture (it runs after merge and feeds the
-    // verdict), so moveTask must not also spawn one. Expected = in-process (below).
-    // moveTask's detached capture stays the sole one only when nobody measures: --skip-post-complete.
     const postCompleteRuns = !options.skipPostComplete;
-    const result = await this.moveTask(taskId, 'done', updatedTask, { skipHealthAfter: postCompleteRuns });
+    const result = await this.moveTask(taskId, 'done', updatedTask);
 
     try {
       this._autoPopThoughtsForCompletedTask(taskId, now);
@@ -2520,100 +2404,6 @@ class TaskAPI {
   }
 }
 
-// ============================================================================
-// TASK_1992/TASK_2104 — Alaya process-lessons echo (best-effort, create-only)
-// ============================================================================
-// Mirrors prompt.js's appendAlayaLessons: same query, same alaya_recall
-// shape, and (TASK_2104) the same TASK_2101 cosine-floor + stack-match
-// gate — loaded from the dependency-free .formation/tools/alaya-gate.js
-// module (require() resolved relative to __dirname; GEN-008) instead of
-// the hand-copied query builder that used to live here with no gate at all.
-// Never affects create's exit code: any failure is swallowed silently.
-// Opt-out: KENAZ_NO_ALAYA_ECHO=1.
-
-// Best-effort: null (not a throw) when unavailable — e.g. a sub-project
-// with no .formation/ checkout — so the caller prints nothing rather than
-// falling back to ungated results.
-function loadAlayaGate() {
-  try {
-    return require('../../.formation/tools/alaya-gate');
-  } catch {
-    return null;
-  }
-}
-
-// fetchImpl/gateImpl: injectable test seams; default to the real fetch and loadAlayaGate().
-async function echoAlayaLessons(taskData, fetchImpl, gateImpl) {
-  if (process.env.KENAZ_NO_ALAYA_ECHO === '1') return;
-
-  const doFetch = fetchImpl || (typeof fetch !== 'undefined' ? fetch : null);
-  if (!doFetch) return;
-
-  const gate = gateImpl !== undefined ? gateImpl : loadAlayaGate();
-  if (!gate) return; // shared gate unavailable — never print ungated results
-
-  const query = gate.buildTaskContextQuery(taskData);
-  if (!query) return;
-
-  const taskStack = gate.deriveTaskStack((taskData && taskData.scope_paths) || []);
-
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 3000);
-  try {
-    const payload = JSON.stringify({
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'tools/call',
-      params: {
-        name: 'alaya_recall',
-        arguments: {
-          query, mode: 'hybrid', seed_types: ['failure_seed', 'lesson_seed'],
-          limit: gate.ALAYA_CANDIDATE_POOL, min_cosine: gate.ALAYA_MIN_COSINE_DEFAULT,
-        },
-      },
-    });
-    const res = await doFetch('http://127.0.0.1:18080/api/mcp', {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Accept': 'application/json, text/event-stream' },
-      body: payload,
-      signal: controller.signal,
-    });
-    if (!res || !res.ok) return;
-    const result = await res.json();
-    if (!result || result.error) return;
-
-    const content = result.result && result.result.content;
-    if (!content || !Array.isArray(content)) return;
-    const textPart = content.find(c => c.type === 'text');
-    if (!textPart || !textPart.text) return;
-
-    let recallData;
-    try { recallData = JSON.parse(textPart.text); } catch { return; }
-    if (!recallData) return;
-
-    let bijas = recallData.bijas || [];
-    if (bijas.length === 0) return;
-
-    bijas = gate.dedupBijas(bijas);
-    // TASK_2104: same relevance gate as prompt.js's appendAlayaLessons —
-    // the server already applied min_cosine, but re-checking (+ the
-    // stack-match half, which the server does not apply) keeps this
-    // correct against a stub/older server and drops stack mismatches.
-    bijas = bijas.filter(b => gate.passesAlayaRelevanceGate(b, taskStack, gate.ALAYA_MIN_COSINE_DEFAULT)).slice(0, 3);
-    if (bijas.length === 0) return;
-
-    console.log('   Alaya lessons for this card:');
-    for (const b of bijas) {
-      const preview = (b.content || '').replace(/\s+/g, ' ').trim().slice(0, 160);
-      console.log(`   - [${b.seed_type || 'seed'}/${b.origin || 'unknown'}] ${preview}`);
-    }
-  } catch {
-    // Best-effort: MCP down, timeout, network error, malformed response — silent.
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
 // TASK_2257: estimated_hours is a finite number >= 0 or null. '' (flag present, empty value)
 // CLEARS the field (null) -- same "clearable" contract as --description/--notes. Anything
 // non-numeric or negative exits 1 instead of persisting NaN / a nonsense value.
@@ -3198,8 +2988,6 @@ Create 選項:
         if (task.estimated_hours != null) console.log(`預估工時: ${task.estimated_hours}h`);
         if (task.branch) console.log(`分支: ${task.branch}`);
 
-        await echoAlayaLessons(taskData);
-
       } else if (command === 'claim') {
         const taskId = args[1];
         if (!taskId) {
@@ -3737,10 +3525,6 @@ module.exports = {
   parseYAML,
   toYAML,
   resolveTasksDir,
-  // TASK_1992/TASK_2104: exported for direct unit-testing with a mocked
-  // fetch (and an injectable alaya-gate module) — no live MCP dependency.
-  loadAlayaGate,
-  echoAlayaLessons,
   // TASK_2142 R2: test seam for injecting a fake pool-status-push module.
   setPoolStatusPush,
 };