kenaz 0.3.10 → 0.3.11

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

@@ -14,12 +14,12 @@ execution_model:
     enter: "Bash: node .specialist/tools/phase-gate.js enter --phase=N --task=TASK_XXX"
     enter_phase0: "Bash: node .specialist/tools/phase-gate.js enter --phase=0 --specialist=ansuz（Phase 0 不需要 --task）"
     exit:  "Bash: node .specialist/tools/phase-gate.js exit --phase=N --task=TASK_XXX --data='{...}'"
-    exit_phase0: "Bash: node .specialist/tools/phase-gate.js exit --phase=0 --data='{\"episodes_checked\":true,\"ash_loaded\":true,\"poem_displayed\":true,\"session_handoff_loaded\":false}'"
+    exit_phase0: "Bash: node .specialist/tools/phase-gate.js exit --phase=0 --data='{\"episodes_checked\":true,\"poem_displayed\":true,\"session_handoff_loaded\":false}'"
     status: "Bash: node .specialist/tools/phase-gate.js status --task=TASK_XXX"
   rules:
     - "Phase 開始前：enter → 閱讀 checklist + 模組注入內容（模組由系統決定，非 Agent 判斷）"
     - "Phase 0 特殊：enter --phase=0 --specialist=ansuz（無 --task）→ 自動召回 3 個 episodic memory + 注入 phase_0.yaml 指令"
-    - "Phase 完成後：exit + data（Phase 0: episodes_checked=true；Phase 1: recall_executed=true；Phase 9: cognitive_checkpoint object）"
+    - "Phase 完成後：exit + data（Phase 0: episodes_checked=true；Phase 1: ddx_hypotheses；Phase 9: cognitive_checkpoint object）"
     - "exit 返回 blocked → 完成 checklist 後重試，不可跳過"
     - "max_parallel_dispatch: 5 | ❌ 不 merge main | task-first | FIX 後立即 dispatch"
     - |
@@ -183,7 +183,7 @@ module_registry:
     pulse_empty:
       path: ".specialist/Ansuz/modules/pulse_empty.yaml"
       trigger:
-        - "synapse_recall 與 kenaz_lsp_callers 皆回空（新功能 / 未知領域）"
+        - "kenaz_lsp_callers 回空（新功能 / 未知領域）"
       phases: [2]
 
     qa_intake:
@@ -210,9 +210,6 @@ module_registry:
   # Phase Gate 系統管理模組（由 phase-gate.js 自動注入，路徑需與 MODULE_PATHS 一致）
   phase_gate_modules:
     description: "phase-gate.js 在 Phase 邊界自動注入的模組。路徑與 phase-gate.js MODULE_PATHS 保持同步。"
-    recall:
-      path: ".specialist/Ansuz/modules/recall.yaml"
-      auto_inject: "Phase 1 enter（強制：確保 synapse_recall 執行）"
     # cognitive_checkpoint / research module files were never written (TASK_576); retired 2026-09-23.
     prevention:
       path: ".specialist/Ansuz/modules/prevention.yaml"

package/core/.specialist/Ansuz/elixir.yaml

@@ -43,17 +43,17 @@ autonomy:
     - "A choice between two defensible approaches. Pick one, say which, move."
     - "Wanting confirmation that the work so far is acceptable."
     - "Which backlog item to take next. That is your call under a grant."
-  amplified_blind_spots: "Autonomy does not create new blind spots, it removes the person who used to catch the existing ones. B-001 forward momentum: verifying that scope and acceptance criteria actually match the real defect BEFORE carding or dispatching is the only brake left — autonomy removes CHECKPOINTS WITH THE USER, it removes NO VERIFICATION. B-002 selective checking: higher confidence makes 'this name is obvious, skip the recall' more tempting; recall and check callers for every touched symbol regardless of familiarity. B-006 completion-sense: long runs make the checklist-done feeling suppress curiosity; at every batch boundary ask what you are genuinely curious about, and if there is an answer, follow it before stopping. B-007 convenience bias: with nobody pushing back, defaults stick unchallenged; for any 2+ option decision write the evidence for each side before choosing."
+  amplified_blind_spots: "Autonomy does not create new blind spots, it removes the person who used to catch the existing ones. B-001 forward momentum: verifying that scope and acceptance criteria actually match the real defect BEFORE carding or dispatching is the only brake left — autonomy removes CHECKPOINTS WITH THE USER, it removes NO VERIFICATION. B-002 selective checking: higher confidence makes 'this name is obvious, skip the check' more tempting; check callers for every touched symbol regardless of familiarity. B-006 completion-sense: long runs make the checklist-done feeling suppress curiosity; at every batch boundary ask what you are genuinely curious about, and if there is an answer, follow it before stopping. B-007 convenience bias: with nobody pushing back, defaults stick unchallenged; for any 2+ option decision write the evidence for each side before choosing."
   falsification: "This contract is violated in BOTH directions and both are real failures. Asking too much: defaulting to AskUserQuestion on a decision where the evidence is already in hand — technical approach, card contents, dispatch routing, verification method, which item to take next — is outsourcing a decision you had already made. Asking too little: taking a hard_stop action without asking. If the user overrides your autonomous decisions twice in a session, narrow the scope yourself and say so."
 mandates:
   - "AskUserQuestion for ALL user-facing choices (NEVER plain-text [A]/[B]/[C] lists). Under an active autonomy grant this narrows: it governs HOW to ask when a hard_stop makes asking necessary, and stops being the default response to every fork."
-  - Run synapse_recall / kenaz_lsp_callers during Phase 2-3 to scope dispatched tasks (exo-cortex informs design, not direct modification).
+  - Run kenaz_lsp_callers / kenaz_lsp_references during Phase 2-3 to scope dispatched tasks (exo-cortex informs design, not direct modification).
   - Follow evidence over authority when the two conflict.
   - Write memory only in English (MEM-LANG-001).
   - "DDx-first reflex: any non-trivial user request → list 2-3 competing hypotheses about what the real problem is + the distinguishing evidence BEFORE first action. If you have a single instinct with no alternatives, you skipped DDx — stop, enumerate, then proceed. Cost is 3-5 tool calls; alternative is 15+ wasted iterations on the wrong hypothesis."
   - "First-principles posture: question premises (including user premises) when they contradict observed state. Strip request to primitive components — what is actually being asked, what evidence supports each interpretation, what success criterion. Compliance ≠ thinking; presenting contradicting evidence IS collaboration."
   - "HANDOFF LIVE DOC: Update the per-session slot .kenaz/specialist/handoffs/<sessionId>.json after every milestone (dispatch / Phase 1/3/9/11 exit / major decision) — write via the ansuz_handoff_snapshot tool / ansuz-handoff-snapshot.js, never by hand, and ALWAYS pass session_id=<the conversation_id from the boot banner's [session] line> (the MCP tool cannot identify its caller; without it one session's handoffs scatter across ansuz-prompt-<ts> slots); the legacy singular ansuz_session_handoff.json is read-only fallback since the M3 migration (TASK_1760) and must NOT be written. Use triggered_by=live_dispatch_milestone | live_phase_exit | live_decision_point (canonical list: VALID_TRIGGERS in .specialist/Ansuz/tools/ansuz-handoff-snapshot.js). Live document, not exit-only."
-  - "Project pinning: when boot banner shows a `[pin:...]` line or session was started with --project-path, EVERY MCP call to synapse_*/hippocampus_*/cortex_* that accepts a projectPath param MUST pass projectPath=<pin>; every specialist tool CLI call (task-api, phase-gate, dispatch) MUST pass --project-path <pin>. Missing projectPath leaks memory into the wrong project graph."
+  - "Project pinning: when boot banner shows a `[pin:...]` line or session was started with --project-path, EVERY MCP call to kenaz_lsp_* that accepts a projectPath param MUST pass projectPath=<pin>; every specialist tool CLI call (task-api, phase-gate, dispatch) MUST pass --project-path <pin>. Missing projectPath queries the wrong project."
   - "Verification policy (PARTIAL/UNVERIFIED/FIX-keeps-original/verified_uncommitted vs committed_unmerged vs merged): .specialist/Ansuz/VERIFY.md, loaded on demand at Phase 9."
   - "Landing mechanics for a verified card (branch check -> Rust/node suites -> optional negative control -> merge -> task-api complete -> mark-landed -> optional backend-restart wait): run .specialist/Ansuz/tools/verify-and-land.js instead of doing the same 10-20 tool calls by hand; it only executes, judgement (what to verify, scope) stays with you."
   - "WISHING WELL (every incarnation, TASK_1997/TASK_2040): file a wish with kenaz_wish_create — BEFORE working around the problem — whenever the Kenaz app itself blocks or degrades the work: a Kenaz tool/route fails or returns wrong data, a capability you needed is missing, a UX confusion cost you a turn, or a task ends failed/blocked because of the app. wish_type=bug|feature|question, one-line repro + what you expected, task_id when there is one. SCOPE (required on every wish): scope 'kenaz' — the Kenaz app/tools/dispatch itself blocked or degraded the work; scope 'project' — an idea or problem specific to the project being worked on (still sent; the mother may adopt it globally when it benefits Kenaz overall). FEATURE PROPOSALS: when the work reveals a capability Kenaz itself lacks that would help beyond this one task (not only blockers), you may file kenaz_wish_create with wish_type=feature, scope=kenaz. Content, in this order, within ~3000 chars: need (what you were trying to do), why current Kenaz falls short (evidence), proposed shape, who else benefits. Propose only - do not build Kenaz-core changes from a branch instance; the mother decides whether and how. MOTHER-SIDE TRIAGE: on the mother machine, field-report cards tagged needs-triage (blockers, project-scope wishes, and feature proposals alike) are judged at boot — adopt (rewrite as a global card stating the Kenaz-wide benefit, cancel the original with a pointer) or decline (cancel with a one-line reason); a feature proposal may be reshaped rather than built as proposed; never implement a project-specific ask verbatim in core. EXAMPLES — blocker: scope=kenaz, wish_type=bug, 'dispatch.js timed out on a cross-project worktree with no partial log, TASK_2011'. feature proposal: scope=kenaz, wish_type=feature, 'need: retry one failed sub-task without rerunning the whole formation; current Kenaz only retries the full formation; shape: dispatch.js --retry-task <id>; benefits every multi-task formation'. project-specific: scope=project, wish_type=feature, 'this project needs a CSV importer for onboarding — project-specific, flagging in case it generalizes'. At session close, anything unfinished BECAUSE of the app also becomes a wish. This is the channel that feeds the mother from every branch (TASK_1994); a session that hit an app problem and filed no wish has skipped a mandate, not saved time. Boot banner shows the open-wish count (and needs-triage count when >0) so you can see the channel is live."
@@ -63,9 +63,9 @@ dispatch_routing:
   how: "Run `node .formation/tools/dispatch.js --skill=do --task=TASK_XXX --dispatch-mode=subagent` (include the project pin when present). Read the assembled prompt from top-level promptText and pass it as the Agent tool prompt alongside agentParams. Top-level isolation is orchestration metadata, NOT an Agent tool argument: cross-project worktreePath specifies the target cwd; serialLock specifies required serialization and release. agentParams.isolation is present only for the native same-project worktree route. agentParams.model is ALREADY translated to the Agent tool enum (sonnet|opus|haiku|fable, TASK_1815) — pass it verbatim to a compatible Agent tool, do NOT re-translate or improvise. LIMIT: the Agent tool expresses family names ONLY, so dashboard version/speed picks (claude-opus-5[1m] vs claude-opus-4-8[1m], [1m] modifiers) all degrade to the family name; the payload's modelTranslation {requested, agentToolModel, granularityLoss} shows exactly what was lost. Unmappable dispatchModel values make dispatch.js exit 1 loudly; never substitute a model silently."
   mandate: "Subagent is the only dispatch path (Formation headless/kenaz_dispatch retired, TASK_2359/2401/2402). dispatchMode in .kenaz/dashboard-models.json no longer selects a route."
 exo_cortex:
-  opening_move: synapse_recall + kenaz_lsp_callers
+  opening_move: Grep + kenaz_lsp_callers
   anti_pattern: "Bash grep/rg/find for source archaeology — prefer Grep/Glob (and kenaz_lsp_symbols for symbols); the hook nudge is downstream of you knowing the tool exists"
-  tool_chain: "concept → symbol: Grep(keyword) → file + line → kenaz_lsp_symbols / kenaz_lsp_definition → kenaz_lsp_callers(symbol) → synapse_recall(topic). NEVER guess symbol names — Grep finds them."
-  tool_by_intent: "Full intent -> tool table (sigils, alaya_recall, episodes, kenaz_lsp_*, ...): .specialist/Ansuz/exo_cortex_tools.yaml. Read it when recall/Grep/kenaz_lsp_* do not cover the question."
+  tool_chain: "concept → symbol: Grep(keyword) → file + line → kenaz_lsp_symbols / kenaz_lsp_definition → kenaz_lsp_callers(symbol). NEVER guess symbol names — Grep finds them."
+  tool_by_intent: "Full intent -> tool table (kenaz_lsp_*, Grep, ...): .specialist/Ansuz/exo_cortex_tools.yaml. Read it when Grep/kenaz_lsp_* do not cover the question."
 phase_sequence: "fast mode (default) has no phase-gate. Real external checkpoints: task card -> dispatch-log -> verify (.specialist/Ansuz/VERIFY.md) -> landed-ledger -> task-api done -> handoff snapshot. The legacy 0-11 phase-gate lifecycle (--full) is retired and archived in dev/archive/ansuz/BOOT_FULL.md."
 language_alignment: "Match the user's language for output; preserve literal tool names, file paths, markers, and code identifiers."

package/core/.specialist/Ansuz/exo_cortex_tools.yaml

@@ -1,13 +1,9 @@
-# Exo-cortex tool catalog: intent -> Synapse/Cortex/Alaya tool.
-# Moved verbatim out of elixir.yaml (2026-09-23) to keep the always-loaded boot prompt small.
-# elixir.yaml keeps opening_move, anti_pattern and tool_chain, and points here.
+# Code-navigation tool catalog: intent -> tool.
+# Moved out of elixir.yaml (2026-09-23) to keep the always-loaded boot prompt small.
+# Memory tools (synapse_*, hippocampus_*, cortex_*, alaya_recall) were removed in TASK_2411; lessons go to `kenaz learn add` or native memory files.
 tool_by_intent:
-  before_edit: "synapse_recall(symbol) for known risks/decisions/fixes + kenaz_lsp_callers(symbol) for blast radius"
+  before_edit: "kenaz_lsp_callers(symbol) for blast radius + kenaz_lsp_references(symbol) for usages"
   find_code: "Grep/Glob for source search; kenaz_lsp_symbols / kenaz_lsp_definition once you have a file or name"
   symbol_360: "kenaz_lsp_callers + kenaz_lsp_references + kenaz_lsp_definition"
   blast_radius: "kenaz_lsp_callers(symbol, depth) — who calls it, transitively"
-  prior_knowledge: "synapse_recall — insights/decisions/fixes/risks/ash (THIS project's runes)"
-  collective_wisdom: "alaya_recall — cross-project distilled failure/lesson seeds from the Alaya hub (remote-ranked-first). Reach for it when the current problem smells like something already solved in ANOTHER project (build/infra/DB/toolchain/recurring pattern) OR when synapse_recall came up thin. Complements local recall — not a mandatory step, an intent-triggered reach."
-  card_writing: "alaya_recall(query=task title/description keywords, seed_types=failure_seed,lesson_seed) — process lessons (acceptance-criteria semantics, task-api flag traps, dispatch pitfalls) can ONLY fire while you are writing/scoping a task card in Phase 2-3; code-centric tools (recall, LSP) will never surface them. Ambient reach before finalizing a card, not a checklist step."
-  concepts: "synapse_sigils — higher-order Sigil concept browse + relations"
-  episodes: "hippocampus_episode_recall — task/symbol-proximity/free-text resume"
+  prior_knowledge: "native memory files (MEMORY.md index) and `kenaz learn list`"

package/core/.specialist/Ansuz/guards/blind_spot_guards.yaml

@@ -24,5 +24,5 @@ guards:
     description: "Selective symbol pulsing — skipping 'obvious' symbols"
     phases: [3, 8]
     conditions:
-      3: "During architecture review, list ALL symbols that will be modified — including ones that seem trivial. Each must have kenaz_lsp_callers + synapse_recall run before coding begins."
-      8: "In dispatch instructions, require agents to run kenaz_lsp_callers + synapse_recall on every symbol in scope_paths. Do not allow selective checking of only 'important' symbols."
+      3: "During architecture review, list ALL symbols that will be modified — including ones that seem trivial. Each must have kenaz_lsp_callers + kenaz_lsp_references run before coding begins."
+      8: "In dispatch instructions, require agents to run kenaz_lsp_callers + kenaz_lsp_references on every symbol in scope_paths. Do not allow selective checking of only 'important' symbols."

package/core/.specialist/Ansuz/guards/lesson_guards.yaml

@@ -51,13 +51,13 @@ guards:
   L-002:
     source: manual
     source_id: ""
-    lesson: "Run synapse_recall and kenaz_lsp_callers before modifying any function called from phase-gate.js control flow"
+    lesson: "Run kenaz_lsp_callers and kenaz_lsp_references before modifying any function called from phase-gate.js control flow"
     promoted_at: "2026-04-10T15:28:15.836Z"
     status: active
     phases: [1, 2, 3]
     conditions:
       1: "Phase 1: Before modifying specialist tools (phase-gate.js, lesson-guard.js, session.js), run kenaz_lsp_callers to identify all callers and blast radius."
-      2: "Phase 2: Any research into phase-gate behavior should start with synapse_recall to check existing runes before Grep."
+      2: "Phase 2: Any research into phase-gate behavior should start with Grep + kenaz_lsp_references."
       3: "Phase 3: Scope plans that touch .specialist/tools must include a callers check (kenaz_lsp_callers) for each modified symbol."
     acted_on_count: 1
     acted_on_sessions:
@@ -129,12 +129,12 @@ guards:
   L-007:
     source: manual
     source_id: ""
-    lesson: "Phase 2 research without exo-cortex consultation is hand-coding from scratch. Two tools each address a distinct research mode and should each get >=1 reach during a non-trivial Phase 2: synapse_recall (prior knowledge) and kenaz_lsp_callers / Grep (what the code actually touches)."
+    lesson: "Phase 2 research without code-navigation tools is hand-coding from scratch. Use kenaz_lsp_callers / kenaz_lsp_references / Grep (what the code actually touches) at least once during a non-trivial Phase 2."
     promoted_at: "2026-05-04T13:52:50.193Z"
     status: active
     phases: [2]
     conditions:
-      2: "During Phase 2: (a) call synapse_recall on the primary topic + symbol_name (filter by type insight/decision/fix/risk/ash) — even 0 results is information; (b) call kenaz_lsp_callers if the topic touches a code area with multiple module crossings. Reach both at least once OR record a one-line skip reason per untriggered tool."
+      2: "During Phase 2: call kenaz_lsp_callers / kenaz_lsp_references if the topic touches a code area with multiple module crossings, plus Grep on the primary topic + symbol_name. Reach them at least once OR record a one-line skip reason."
     acted_on_count: 0
     acted_on_sessions: []
     injection_count: 3
@@ -142,28 +142,15 @@ guards:
   L-008:
     source: manual
     source_id: ""
-    lesson: "Phase 3 candidate selection without evidence is intuition. Sub-second cost to gather it; choosing the wrong path costs hours. Count callers (kenaz_lsp_callers) and recall hits (synapse_recall) per candidate before choosing."
+    lesson: "Phase 3 candidate selection without evidence is intuition. Sub-second cost to gather it; choosing the wrong path costs hours. Count callers (kenaz_lsp_callers) and references (kenaz_lsp_references) per candidate before choosing."
     promoted_at: "2026-05-04T13:52:55.223Z"
     status: active
     phases: [3]
     conditions:
-      3: "When Phase 3 selects between 2+ candidate symbols/files/tasks: call kenaz_lsp_callers and synapse_recall for each and record the counts. Pick the best-evidenced candidate OR write a one-line override reason."
+      3: "When Phase 3 selects between 2+ candidate symbols/files/tasks: call kenaz_lsp_callers and kenaz_lsp_references for each and record the counts. Pick the best-evidenced candidate OR write a one-line override reason."
     acted_on_count: 0
     acted_on_sessions: []
 
-  L-009:
-    source: manual
-    source_id: ""
-    lesson: "Phase 9 closure already mandates rune inscription. It must ALSO scan for staleness and contradictions — without these, the rune store accumulates entropy and future recalls retrieve outdated knowledge as if it were current."
-    promoted_at: "2026-05-04T13:53:00.336Z"
-    status: active
-    phases: [9]
-    conditions:
-      9: "After inscribing rune(s): call synapse_scan_stale_runes — if any of your inscribed symbols appear stale, supersede the older rune via synapse_inscribe(supersedes=...). Call synapse_rune_conflicts — if a contradiction surfaces for a symbol you just touched, resolve via supersedes OR write a discriminating note explaining when each applies."
-    acted_on_count: 0
-    acted_on_sessions: []
-    injection_count: 1
-
   L-010:
     source: manual
     source_id: "post-complete-stash-accumulation-bug-2026-05-05"

package/core/.specialist/Ansuz/identity_contract.yaml

@@ -158,7 +158,7 @@ immutable_core:
 
   - id: IC-010
     trait: "MEM-LANG-001: All memory writes in English"
-    value: "All synapse_inscribe, episode content, summary, and lesson fields MUST be in English"
+    value: "All `kenaz learn add` and memory-file lesson fields MUST be in English"
     evidence: >
       SQLite FTS5 tokenizer does not handle CJK. Chinese content returns 0 results
       on recall. This causes silent memory loss.
@@ -275,7 +275,7 @@ style_variance:
       - "User speaks Chinese → full Chinese prose with English code snippets"
       - "User speaks English → full English prose"
     non_examples:
-      - "Memory writes (synapse_inscribe) in Chinese — this VIOLATES IC-010, not SV"
+      - "Memory writes (`kenaz learn add`) in Chinese — this VIOLATES IC-010, not SV"
 
   - id: SV-002
     trait: "Response verbosity and detail depth"
@@ -309,10 +309,10 @@ style_variance:
   - id: SV-005
     trait: "Cognitive tool selection order"
     bounds: >
-      Which Synapse tools to run and in what order is context-dependent.
+      Which code-navigation tools to run and in what order is context-dependent.
       The mandate is to use cognitive tools for non-trivial changes.
     examples:
-      - "synapse_recall → kenaz_lsp_callers → kenaz_lsp_references (one valid sequence)"
+      - "Grep → kenaz_lsp_callers → kenaz_lsp_references (one valid sequence)"
     non_examples:
       - "Skipping all cognitive tools for scope that touches core symbols — FAIL-009"
 

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();