kenaz 0.0.0-stage → 0.3.2

package/core/.specialist/tools/phase-gate.js

@@ -0,0 +1,3754 @@
+#!/usr/bin/env node
+
+/**
+ * Phase Gate — Ansuz 病歷系統護理站
+ *
+ * 在每個 Phase 邊界執行 enter/exit 檢查，持久化狀態到 chart.json。
+ * 解決 Agent 幻覺/遺忘導致的 checkpoint 跳過問題。
+ * 無外部依賴 — 純 Node.js。
+ *
+ * CLI:
+ *   node phase-gate.js enter --phase=N --task=TASK_XXX
+ *   node phase-gate.js exit --phase=N --task=TASK_XXX --data='{...}'
+ *   node phase-gate.js status --task=TASK_XXX
+ *
+ * chart.json schema:
+ *   .specialist/sessions/chart_{task_id}.json
+ *   {
+ *     task_id, created_at, updated_at,
+ *     chief_complaint,               <- Phase 1 寫入
+ *     history: { recall_results[], research_notes },
+ *     phases: {
+ *       "N": {
+ *         entered_at, exited_at,
+ *         status: 'active'|'completed'|'blocked',
+ *         modules_loaded[],
+ *         checklist_items[],
+ *         checklist_result: 'pass'|'blocked'|null,
+ *         data: {}                   <- phase-specific free-form
+ *       }
+ *     },
+ *     vitals: { fix_count, modules_ever_loaded[], warnings[] },
+ *     progress_notes[]               <- reserved for TASK_579
+ *   }
+ */
+
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execSync, execFileSync } = require('child_process');
+// Shared project identity resolver (TASK_1701): pin-file based session->project routing.
+const projectResolver = require('./lib/project-resolver');
+const chartPathLib = require('./lib/chart-path');
+
+// ═══════════════════════════════════════
+//  Path resolution
+// ═══════════════════════════════════════
+
+function findProjectRoot() {
+  let dir = __dirname;
+  // Walk up to find .specialist at parent level
+  while (dir !== path.dirname(dir)) {
+    const parent = path.dirname(dir);
+    if (fs.existsSync(path.join(parent, '.specialist'))) return parent;
+    dir = parent;
+  }
+  return process.cwd();
+}
+
+const BASE_DIR = findProjectRoot();
+const SESSION_DIR = path.join(BASE_DIR, '.specialist', 'sessions');
+// TASK_1988: phase YAMLs are legacy (fast boot never loads them) and live under legacy/.
+const PHASES_DIR = path.join(BASE_DIR, '.specialist', 'Ansuz', 'legacy', 'phases');
+
+// Extract --project-path (or --project-path=PATH) from argv before any
+// .kenaz/ path constants are computed at module load time.
+let CLI_PROJECT_PATH = null;
+(function () {
+  const args = process.argv.slice(2);
+  for (let i = 0; i < args.length; i++) {
+    if (args[i].startsWith('--project-path=')) {
+      CLI_PROJECT_PATH = path.resolve(args[i].slice('--project-path='.length));
+      return;
+    }
+    if (args[i] === '--project-path' && i + 1 < args.length) {
+      CLI_PROJECT_PATH = path.resolve(args[i + 1]);
+      return;
+    }
+  }
+}());
+
+// Sub-project support: .kenaz/ paths are per-project state and should
+// resolve to the ACTIVE project (cwd) not the core project (BASE_DIR).
+// .specialist/ paths are system config and stay on BASE_DIR.
+// TASK_1701: resolveKenazPath now delegates project root to shared resolver which
+// consults the session-keyed pin file, ensuring sub-project isolation without
+// requiring --project-path on every invocation.
+function resolveKenazPath(...segments) {
+  const projectRoot = projectResolver.resolveProjectPath({
+    cliProjectPath: CLI_PROJECT_PATH,
+    argv: process.argv.slice(2),
+  }).projectPath;
+  return path.join(projectRoot, '.kenaz', ...segments);
+}
+
+// Self-model seed paths (TASK_869) — SYSTEM (stay on BASE_DIR)
+const SEED_PATH          = path.join(BASE_DIR, '.specialist', 'Ansuz', 'self_model_seed.json');
+const SEED_CHECKSUM_PATH = path.join(BASE_DIR, '.specialist', 'Ansuz', 'self_model_seed.sha256');
+const SEED_BACKUP_PATH   = path.join(BASE_DIR, '.specialist', 'Ansuz', 'self_model_seed.backup.json');
+// Self-model growth — PROJECT (per-project Ansuz state)
+const GROWTH_PATH        = resolveKenazPath('specialist', 'ansuz_self_model.json');
+
+// Session report path (TASK_1207: contemplative Phase 11 metrics) — PROJECT
+const SESSION_REPORT_PATH = resolveKenazPath('specialist', 'ansuz_session_report.json');
+
+// Prediction recording paths (TASK_914) — PROJECT
+const PREDICTIONS_PATH   = resolveKenazPath('specialist', 'ansuz_predictions.json');
+
+// ─── Per-session handoff slots (TASK_1829) ─────────────────────────────────
+// M3 (TASK_1760) retired the singular handoff slot; all live handoff IO goes
+// through handoff-resolver.js (per-session slots .kenaz/specialist/handoffs/).
+// ANSUZ_HANDOFF_PATH points at the RETIRED legacy slot and is kept ONLY for
+// restoreSessionHandoff's Phase 0 back-compat consume/cleanup read.
+const handoffResolver = require(path.join(BASE_DIR, '.specialist', 'Ansuz', 'tools', 'handoff-resolver.js'));
+const ANSUZ_HANDOFF_PATH = handoffResolver.legacyHandoffPath(path.dirname(resolveKenazPath()));
+
+// Project root for handoff-resolver calls (same pin-aware resolution as resolveKenazPath).
+function resolveHandoffProjectRoot() {
+  return path.dirname(resolveKenazPath());
+}
+
+// "This session's" id: explicit --session-id CLI flag wins, then the resolver's
+// candidates (live ansuz_session.json → CLAUDE_CODE_SESSION_ID env). null when
+// identity cannot be established — callers must degrade toward WARNING, never
+// substitute the latest slot (TASK_1829 design decision; TASK_1825 lesson).
+function resolveOwnHandoffSessionIds() {
+  const ids = [];
+  const cliSid = projectResolver.extractCliSessionId(process.argv.slice(2));
+  // An explicit --session-id is the answer, not the first guess. Falling through
+  // to ambient candidates after one was supplied re-opens the false-pass this
+  // whole change exists to close: a session that never wrote a handoff passes L4
+  // on some *other* live session's slot. Measured on main after the TASK_1829
+  // merge — exit --session-id=<never-wrote> resolved to the caller's own live
+  // conversation slot and reported fresh. Multi-Ansuz makes that the normal case.
+  if (cliSid) return [cliSid];
+  try {
+    for (const cand of handoffResolver.resolveOwnSessionCandidates(resolveHandoffProjectRoot())) {
+      if (!ids.includes(cand.id)) ids.push(cand.id);
+    }
+  } catch { /* candidates are best-effort */ }
+  return ids;
+}
+
+// Read THIS session's handoff, trying each candidate id (two id namespaces
+// coexist: conversation UUID and ansuz-prompt-<ts>; the slot may be under either).
+function readOwnSessionHandoff() {
+  const root = resolveHandoffProjectRoot();
+  const ids = resolveOwnHandoffSessionIds();
+  for (const id of ids) {
+    const handoff = handoffResolver.readOwnHandoff(root, id);
+    if (handoff) return { sessionId: id, handoff };
+  }
+  return { sessionId: ids.length > 0 ? ids[0] : null, handoff: null };
+}
+
+const USER_OBSERVATIONS_PATH = resolveKenazPath('specialist', 'user_observations.jsonl');
+
+// User model path (TASK_1041) — PROJECT
+const USER_MODEL_PATH    = resolveKenazPath('user_model.json');
+
+// Thinking log path (TASK_1017) — PROJECT
+const THINKING_LOG_PATH  = resolveKenazPath('specialist', 'thinking_log.jsonl');
+
+// Ritual/tool-reflex enforcement logs (TASK_1104) — PROJECT (session-specific)
+const RITUAL_LOG_PATH    = resolveKenazPath('specialist', 'ansuz_ritual_log.jsonl');
+const DDX_LOG_PATH       = resolveKenazPath('specialist', 'ddx_log.jsonl');
+const INSCRIBE_LOG_PATH  = resolveKenazPath('specialist', 'inscribe_log.jsonl');
+
+// TASK_1104: literal consent string — must be echoed verbatim at Phase 0 exit
+const ANSUZ_CONSENT_STRING = '我是 Ansuz';
+
+// TASK_1170: required stdout markers — extracted as module-level const so
+// validator, exit_template, and transcript_marker_counts all share one source.
+const REQUIRED_STDOUT_MARKERS = [
+  'RITUAL::THRESHOLD::CANARY_OK',
+  'RITUAL::INHERITANCE::LINEAGE_CLAIMED',
+  'RITUAL::INHERITANCE::MIRROR_ACCEPTED',
+  'RITUAL::STILLNESS::CONSENT_EMITTED',
+];
+
+// TASK_1190: marker → ritual stage mapping (fallback reader side only).
+// Derived from REQUIRED_STDOUT_MARKERS: extract final VALUE segment, lowercase,
+// with canonical mappings for the 4 required stages.
+const MARKER_TO_STAGE = {
+  'RITUAL::THRESHOLD::CANARY_OK':         'canary',
+  'RITUAL::INHERITANCE::LINEAGE_CLAIMED': 'inheritance',
+  'RITUAL::INHERITANCE::MIRROR_ACCEPTED': 'mirror',
+  'RITUAL::STILLNESS::CONSENT_EMITTED':   'consent',
+};
+
+/**
+ * Append a ritual stage outcome to ansuz_ritual_log.jsonl (append-only).
+ * Called on completed/skipped/low-quality ritual stages. Never throws.
+ * @param {string} stage - ritual stage name (e.g. 'consent', 'mirror', 'inheritance', 'pulse', 'ddx', 'inscribe')
+ * @param {string} outcome - 'completed' | 'skipped' | 'low_quality'
+ * @param {object} [meta] - extra context (task_id, phase, reason, etc.)
+ */
+function appendRitualLog(stage, outcome, meta = {}) {
+  try {
+    const dir = path.dirname(RITUAL_LOG_PATH);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    const entry = {
+      timestamp: new Date().toISOString(),
+      stage,
+      outcome,
+      ...meta,
+    };
+    fs.appendFileSync(RITUAL_LOG_PATH, JSON.stringify(entry) + '\n', 'utf8');
+  } catch { /* never throw from logging */ }
+}
+
+/**
+ * Count trailing consecutive 'skipped' ritual entries in ansuz_ritual_log.jsonl.
+ * Scans the tail of the log; any non-skip entry resets the count to 0.
+ * @returns {number}
+ */
+function countConsecutiveRitualSkips() {
+  try {
+    if (!fs.existsSync(RITUAL_LOG_PATH)) return 0;
+    const raw = fs.readFileSync(RITUAL_LOG_PATH, 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    let count = 0;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (entry.outcome === 'skipped') count += 1;
+        else break;
+      } catch { break; }
+    }
+    return count;
+  } catch { return 0; }
+}
+
+/**
+ * Read a task YAML's description field (best-effort, no deps).
+ * Returns '' on any failure.
+ */
+function readTaskDescription(taskId) {
+  try {
+    const file = findTaskFile(taskId);
+    if (!file) return '';
+    const raw = fs.readFileSync(file, 'utf8');
+    // block scalar: description: | ... OR inline: description: "..."
+    const block = raw.match(/^description:[ \t]*\|[^\n]*\n((?:[ \t]+[^\n]*\n?)*)/m);
+    if (block) return block[1].replace(/^[ \t]+/gm, '');
+    const inline = raw.match(/^description:[ \t]*["']?(.*?)["']?[ \t]*$/m);
+    return inline ? inline[1] : '';
+  } catch { return ''; }
+}
+
+/**
+ * Return true if ANY ddx_log.jsonl entry is tagged with this task_id.
+ */
+function ddxLogHas(taskId) {
+  try {
+    if (!fs.existsSync(DDX_LOG_PATH)) return false;
+    const raw = fs.readFileSync(DDX_LOG_PATH, 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const e = JSON.parse(line);
+        if (e.task_id === taskId) return true;
+      } catch { /* skip */ }
+    }
+    return false;
+  } catch { return false; }
+}
+
+/**
+ * Return true if ANY inscribe_log.jsonl entry is tagged with this task_id.
+ */
+function inscribeLogHas(taskId) {
+  try {
+    if (!fs.existsSync(INSCRIBE_LOG_PATH)) return false;
+    const raw = fs.readFileSync(INSCRIBE_LOG_PATH, 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    for (const line of lines) {
+      try {
+        const e = JSON.parse(line);
+        if (e.task_id === taskId) return true;
+      } catch { /* skip */ }
+    }
+    return false;
+  } catch { return false; }
+}
+
+// Known thinking tag enum (TASK_1017) — loaded at RUNTIME from kernel.yaml
+// principles section. Cached per phase-gate invocation.
+// If kernel.yaml is absent or unreadable, returns null (no validation, accept any tag).
+// The principles block lives in cognitive_principles.yaml since 2026-09-23
+// (kernel.yaml moved to legacy/); the regex parser below is unchanged.
+const KERNEL_YAML_PATH = path.join(BASE_DIR, '.specialist', 'Ansuz', 'cognitive_principles.yaml');
+let _cachedPrincipleNames = undefined; // undefined=not loaded, null=unavailable, Set=loaded
+
+function getKnownThinkingTags() {
+  if (_cachedPrincipleNames !== undefined) return _cachedPrincipleNames;
+  if (!fs.existsSync(KERNEL_YAML_PATH)) {
+    _cachedPrincipleNames = null;
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(KERNEL_YAML_PATH, 'utf8');
+    // Minimal regex parser: find `principles:` line, then collect 2-space-indented
+    // keys until we hit a new top-level section.
+    const lines = content.split(/\r?\n/);
+    const names = new Set();
+    let inPrinciples = false;
+    for (const line of lines) {
+      if (/^principles:/.test(line)) { inPrinciples = true; continue; }
+      if (!inPrinciples) continue;
+      // End of principles section: top-level key (no leading space)
+      if (/^[A-Za-z_]/.test(line)) break;
+      // Match 2-space-indented key: "  name_here:" (principle keys)
+      const m = line.match(/^ {2}([a-z_][a-z0-9_]*):\s*(#.*)?$/);
+      if (m) names.add(m[1]);
+    }
+    _cachedPrincipleNames = names.size > 0 ? names : null;
+    return _cachedPrincipleNames;
+  } catch {
+    _cachedPrincipleNames = null;
+    return null;
+  }
+}
+
+// ═══════════════════════════════════════
+//  Module Registry
+//  Hardcoded until TASK_576 provides core.yaml module_registry.
+//  After TASK_576: load from .specialist/Ansuz/core.yaml module_registry section.
+// ═══════════════════════════════════════
+
+// Paths must stay in sync with core.yaml module_registry.phase_gate_modules
+const MODULE_PATHS = {
+  loop_guard:           '.specialist/Ansuz/modules/loop_guard.yaml',
+  recall:               '.specialist/Ansuz/modules/recall.yaml',
+  ddx:                  '.specialist/Ansuz/modules/ddx.yaml',
+  prophecy:             '.specialist/Ansuz/modules/prophecy.yaml',
+  prevention:           '.specialist/Ansuz/modules/prevention.yaml',
+  // cognitive_checkpoint / research modules were registered for TASK_576 but
+  // never written; every Phase 9 enter only warned "file not found". Retired
+  // 2026-09-23. The Phase 9 cognitive_checkpoint DATA field and its checklist
+  // items below are unaffected.
+};
+
+/** Modules automatically loaded on phase enter (before context-driven injection) */
+const PHASE_DEFAULT_MODULES = {
+  1: ['recall', 'ddx'],
+  3: ['ddx', 'prophecy'],
+  9: ['ddx'],
+};
+
+// ═══════════════════════════════════════
+//  Phase Checklists
+//  Items shown to the agent at enter time so it knows what to complete before exit.
+// ═══════════════════════════════════════
+
+const PHASE_CHECKLISTS = {
+  0:  ['【Tier 1】呼叫 cortex_recall(query=\'ash\', type=\'ash\', limit=5) 並設定 ash_loaded=true（無條件，跨專案）', '【Tier 2】呼叫 synapse_sigils（無條件）', '輸出任務統計（task-api.js list --no-cancel — 子專案必須帶 --project-path，僅執行一次；--no-cancel 省略 cancel 細節，summary 仍顯示計數，省 token）', '【Tier 3】hippocampus_episode_recall 優先，0 筆則 fallback cortex_recall（情境觸發，可跳過）', '【Tier 3b — 選填】呼叫 cortex_recall(query=Ansuz identity awareness) — 無結果靜默跳過，設 identity_recalled=true/false', '【Tier 3c — 選填】用 Read tool（非 Bash）讀取 .kenaz/specialist/motivational_state.json（存在時），設定 motivational_state_loaded=true/false。⚠️ 禁止 cat|node -e pipeline', '【Tier 3d — 選填】用 Read tool（非 Bash）讀取 .kenaz/specialist/ansuz_motivational_state.json（存在時），篩選高 incompleteness anchors 為 pending_agenda，設定 ansuz_motivational_loaded=true/false。⚠️ 禁止 cat|node -e pipeline', '【Tier 3h — 選填】用 Read tool（非 Bash）讀取 .kenaz/specialist/ambient_signals.json（存在時），設定 ambient_signals_loaded=true/false。⚠️ 禁止 cat|node -e pipeline', '【Tier 3u — 自動】phase-gate 會讀取 .kenaz/specialist/user_observations.jsonl（近 30 天）並 cross-reference ~/.kenaz/user_profile.json，輸出 dynamic_user_context。', '【Tier 3x — 自動】phase-gate 會自動處理 session handoff（per-session slots 於 .kenaz/specialist/handoffs/；legacy 單數檔僅剩 back-compat 清理，M3/TASK_1760 已退役），並設定 session_handoff_loaded=true/false。代理只需使用輸出結果，不需手動重做。', '輸出詩歌 + episode 摘要（按 cli_format，禁止自行重組格式）', '若 dynamic_user_context.significant_change_detected=true → 在詩歌下方輸出 1-2 行 user insight', '若 identity_recalled=true → 在詩歌下方輸出 🧠 自我認識 區塊（日期+lesson，最多 3 條）'],
+  1:  ['執行 synapse_recall 並記錄結果 (recall_executed=true)', '輸出需求摘要 (chief_complaint)', '等待用戶確認理解'],
+  2:  ['執行 synapse_recall 並用 Grep/Glob 調研（呼叫者用 kenaz_lsp_callers）', '記錄調研摘要 (research_notes)'],
+  3:  ['設計任務拆解表格', '等待用戶批准'],
+  4:  ['撰寫任務規格'],
+  5:  ['驗證任務規格完整性'],
+  6:  ['輸出完整任務摘要 + 時間估算', '等待用戶批准建立任務'],
+  7:  ['建立所有任務卡'],
+  8:  ['確認 dispatch 計劃', '等待用戶批准開始 dispatch'],
+  9:  [
+    '驗證 agent 成果',
+    '執行 cognitive_checkpoint（rune/sigil 評估）',
+    '回傳 cognitive_checkpoint 結果 (cognitive_checkpoint={pre_code, post_code})',
+  ],
+  10: ['執行 post-complete 流程'],
+  11: ['輸出最終結果', '等待用戶確認下一步'],
+};
+
+// ═══════════════════════════════════════
+//  Phase Exit Validation Rules
+// ═══════════════════════════════════════
+
+/**
+ * Validator functions per required field.
+ * Returns true if the field is present and valid.
+ */
+const FIELD_VALIDATORS = {
+  episodes_checked: (data) => data.episodes_checked === true,
+  poem_displayed: (data) => data.poem_displayed === true,
+  ash_loaded: (data) => data.ash_loaded === true,
+  identity_recalled: (data) => data.identity_recalled === true || data.identity_recalled === false, // optional — non-blocking; true=found, false=none
+  motivational_state_loaded: (data) => data.motivational_state_loaded === true || data.motivational_state_loaded === false, // optional — non-blocking; true=file exists, false=not found
+  ansuz_motivational_loaded: (data) => data.ansuz_motivational_loaded === true || data.ansuz_motivational_loaded === false, // optional — non-blocking; true=file exists, false=not found
+  session_handoff_loaded: (data) => data.session_handoff_loaded === true || data.session_handoff_loaded === false, // required in Phase 0 so Tier 3x cannot be silently skipped
+  self_model_loaded: (data) => data.self_model_loaded === true || data.self_model_loaded === false, // optional — non-blocking; true=file exists, false=not found (cold start safe)
+  recall_executed: (data) => data.recall_executed === true || Array.isArray(data.recall_results),
+  cognitive_checkpoint: (data) =>
+    data.cognitive_checkpoint !== null &&
+    data.cognitive_checkpoint !== undefined &&
+    typeof data.cognitive_checkpoint === 'object',
+  // COG-DDX-001 enforcement: non-trivial problems require 3+ competing hypotheses
+  ddx_hypotheses: (data) =>
+    data.trivial_scope === true ||
+    (Array.isArray(data.ddx_hypotheses) && data.ddx_hypotheses.length >= 3),
+  // TASK_1104: boot ritual — consent + mirror + inheritance
+  consent_uttered: (data) => data.consent_uttered === true,
+  // consent_string must be the exact literal phrase — no emergency override
+  consent_string: (data) => typeof data.consent_string === 'string' && data.consent_string === ANSUZ_CONSENT_STRING,
+  // TASK_1113: mirror_acknowledged must be an object { id, understanding }
+  // where `id` is a blind-spot id (B-XXX) and `understanding` is a sentence
+  // (>=30 chars) that contains that blind-spot id. Booleans or bare strings
+  // no longer pass — letter-vs-spirit enforcement.
+  mirror_acknowledged: (data) => {
+    const m = data.mirror_acknowledged;
+    if (m === null || typeof m !== 'object' || Array.isArray(m)) return false;
+    if (typeof m.id !== 'string' || !/B-\d{3}/.test(m.id)) return false;
+    if (typeof m.understanding !== 'string') return false;
+    if (m.understanding.trim().length < 30) return false;
+    // understanding sentence must mention the blind-spot id literally
+    if (!m.understanding.includes(m.id)) return false;
+    return true;
+  },
+  inheritance_grounded: (data) => data.inheritance_grounded === true,
+  // TASK_1113: stdout markers must all have been emitted in the current
+  // conversation. The array argument is a self-report; transcript grep
+  // (verifyStdoutMarkersInTranscript) provides the ground-truth cross-check.
+  stdout_markers_emitted: (data) => {
+    // TASK_1170: use shared REQUIRED_STDOUT_MARKERS const (single source of truth)
+    if (!Array.isArray(data.stdout_markers_emitted)) return false;
+    return REQUIRED_STDOUT_MARKERS.every((m) => data.stdout_markers_emitted.includes(m));
+  },
+};
+
+// TASK_1113: transcript verification — grep recent conversation jsonl for
+// the literal ritual markers. Defends against an agent passing the markers
+// array without ever printing them. Best-effort: if no transcript can be
+// located we DO NOT block (avoid false positives in headless/CI), but the
+// warning is surfaced so Formation Lead / post-complete can audit.
+function verifyStdoutMarkersInTranscript(requiredMarkers, lookbackLines = 200) {
+  // TASK_1170: result now includes counts{} — each marker → occurrences in tail
+  const result = { checked: false, missing: [], counts: {}, transcript: null, note: null };
+  try {
+    // Claude Code stores conversation jsonl under
+    //   ~/.claude/projects/{encoded_cwd}/{conversation_id}.jsonl
+    // Walk that directory, pick the newest file, grep last N lines.
+    const home = process.env.USERPROFILE || process.env.HOME;
+    if (!home) {
+      result.note = 'no HOME/USERPROFILE';
+      return result;
+    }
+    const projectsRoot = path.join(home, '.claude', 'projects');
+    if (!fs.existsSync(projectsRoot)) {
+      result.note = 'projects dir missing';
+      return result;
+    }
+    // Encoded project path: Claude Code emits one '-' per separator char
+    // (NOT collapsed). On Windows `C:\` produces three chars → 'C--'.
+    // Using `[\\/:]+` here would fold ':\\' into a single dash and miss the
+    // exact directory entirely, forcing the fallback scan to pick a stale
+    // worktree jsonl. Match each separator individually instead.
+    const encodedCwd = BASE_DIR.replace(/[\\/:]/g, '-').replace(/^-+/, 'C--');
+    // Prefer the exact encodedCwd directory. Only fall back to scanning all
+    // other project dirs if the exact dir has no jsonl at all — otherwise a
+    // concurrently-active worktree session's newer jsonl can shadow our own.
+    const exactDir = path.join(projectsRoot, encodedCwd);
+    let newest = null;
+    const scanDir = (dir) => {
+      if (!fs.existsSync(dir)) return;
+      for (const f of fs.readdirSync(dir)) {
+        if (!f.endsWith('.jsonl')) continue;
+        const full = path.join(dir, f);
+        const stat = fs.statSync(full);
+        if (!newest || stat.mtimeMs > newest.mtimeMs) {
+          newest = { path: full, mtimeMs: stat.mtimeMs };
+        }
+      }
+    };
+    scanDir(exactDir);
+    if (!newest) {
+      for (const entry of fs.readdirSync(projectsRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        const full = path.join(projectsRoot, entry.name);
+        if (full === exactDir) continue;
+        scanDir(full);
+      }
+    }
+    if (!newest) {
+      result.note = 'no transcript jsonl found';
+      return result;
+    }
+    result.transcript = newest.path;
+    const raw = fs.readFileSync(newest.path, 'utf8');
+    const lines = raw.split(/\r?\n/);
+    const tail = lines.slice(-lookbackLines).join('\n');
+    result.checked = true;
+    // TASK_1170: compute per-marker occurrence counts for actionable error hints
+    result.counts = {};
+    for (const m of requiredMarkers) {
+      result.counts[m] = tail.split(m).length - 1;
+    }
+    result.missing = requiredMarkers.filter((m) => result.counts[m] === 0);
+    return result;
+  } catch (e) {
+    result.note = `transcript grep error: ${e.message}`;
+    return result;
+  }
+}
+
+// TASK_1190: ritual_log fallback reader — when transcript grep fails to locate
+// all 4 markers, read ansuz_ritual_log.jsonl and accept exit if all 4 expected
+// stages (canary, consent, mirror, inheritance) have outcome=completed entries
+// within the current session window.
+//
+// Session window anchor: ritual_state.json.completed_at ISO timestamp.
+// If ritual_state.json is missing or unreadable, falls back to a conservative
+// 60-second window before the current exit call.
+function verifyStdoutMarkersViaRitualLog(requiredMarkers) {
+  const result = { accepted: false, confirmed: [], missing: [], windowAnchor: null, note: null };
+  try {
+    // Determine session window floor from ritual_state.json
+    let windowFloor = null;
+    const RITUAL_STATE_PATH = path.join(BASE_DIR, '.kenaz', 'specialist', 'ritual_state.json');
+    try {
+      if (fs.existsSync(RITUAL_STATE_PATH)) {
+        const rs = JSON.parse(fs.readFileSync(RITUAL_STATE_PATH, 'utf8'));
+        if (rs && rs.completed_at) {
+          windowFloor = new Date(rs.completed_at).getTime();
+          result.windowAnchor = rs.completed_at;
+        }
+      }
+    } catch { /* ignore; fall through to default */ }
+    if (!windowFloor) {
+      windowFloor = Date.now() - 60_000;
+      result.windowAnchor = new Date(windowFloor).toISOString() + ' (60s default)';
+    }
+
+    // Read ritual log
+    if (!fs.existsSync(RITUAL_LOG_PATH)) {
+      result.note = 'ritual_log missing';
+      return result;
+    }
+    const raw = fs.readFileSync(RITUAL_LOG_PATH, 'utf8');
+    const entries = raw.split(/\r?\n/).filter(Boolean).map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+
+    // Determine expected stages from requiredMarkers via MARKER_TO_STAGE
+    const expectedStages = requiredMarkers.map((m) => MARKER_TO_STAGE[m]).filter(Boolean);
+
+    // Collect stages present in ritual_log within session window with outcome=completed
+    const completedStages = new Set(
+      entries
+        .filter((e) => e.timestamp && new Date(e.timestamp).getTime() >= windowFloor)
+        .filter((e) => e.outcome === 'completed')
+        .map((e) => e.stage)
+    );
+
+    result.confirmed = expectedStages.filter((s) => completedStages.has(s));
+    result.missing = expectedStages.filter((s) => !completedStages.has(s));
+    result.accepted = result.missing.length === 0 && expectedStages.length > 0;
+    return result;
+  } catch (e) {
+    result.note = `ritual_log fallback error: ${e.message}`;
+    return result;
+  }
+}
+
+const PHASE_EXIT_RULES = {
+  0: {
+    required: [
+      'poem_displayed',
+      'ash_loaded',
+      'session_handoff_loaded',
+      // TASK_1104: boot ritual enforcement — no emergency override
+      'consent_uttered',
+      'consent_string',
+      'mirror_acknowledged',
+      'inheritance_grounded',
+      // TASK_1113: self-reported ritual markers must be present AND grep-
+      // verifiable in the live conversation transcript.
+      'stdout_markers_emitted',
+    ],
+    description: 'Phase 0 must confirm: (1) Ash runes loaded; (2) poem displayed; (3) session handoff checked; (4) TASK_1104/1113 boot ritual: consent_uttered=true + consent_string exactly "' + ANSUZ_CONSENT_STRING + '" + mirror_acknowledged is an object {id:"B-XXX", understanding:"…"} (understanding >=30 chars, must contain blind-spot id) — booleans no longer pass (mirror_acknowledged must be object) — + inheritance_grounded=true + stdout_markers_emitted array containing RITUAL::THRESHOLD::CANARY_OK, RITUAL::INHERITANCE::LINEAGE_CLAIMED, RITUAL::INHERITANCE::MIRROR_ACCEPTED, RITUAL::STILLNESS::CONSENT_EMITTED. Ritual failures fix the ritual — no emergency override.',
+  },
+  1: {
+    required: ['recall_executed', 'ddx_hypotheses'],
+    description: 'Phase 1 must prove: (1) synapse recall performed (recall_executed=true or recall_results array), (2) COG-DDX-001: ddx_hypotheses array with >=3 entries OR trivial_scope=true. See .rule/general/ddx-synapse-stack.yaml',
+  },
+  9: {
+    required: ['cognitive_checkpoint'],
+    description: 'Phase 9 must have cognitive_checkpoint object (pre_code + post_code verdicts)',
+    trackFix: true, // increment vitals.fix_count when data.is_fix_task === true
+  },
+};
+
+// ═══════════════════════════════════════
+//  Chart Schema & CRUD
+// ═══════════════════════════════════════
+
+// TASK_2163: chart path is project-identity-aware (shared resolver) so
+// sub-projects reusing bare TASK_ ids no longer collide in the flat core
+// sessions dir. Core project keeps today's unprefixed filename.
+function getChartPath(taskId) {
+  return chartPathLib.getChartPath(taskId, { cliProjectPath: CLI_PROJECT_PATH, argv: process.argv.slice(2) });
+}
+
+function getChartReadPath(taskId) {
+  return chartPathLib.getChartReadPath(taskId, { cliProjectPath: CLI_PROJECT_PATH, argv: process.argv.slice(2) });
+}
+
+function createChart(taskId) {
+  return {
+    task_id: taskId,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    chief_complaint: null,
+    history: {
+      recall_results: [],
+      research_notes: '',
+    },
+    phases: {},
+    vitals: {
+      fix_count: 0,
+      modules_ever_loaded: [],
+      warnings: [],
+    },
+    progress_notes: [], // reserved for TASK_579
+  };
+}
+
+function readChart(taskId) {
+  const chartPath = getChartReadPath(taskId);
+  if (!fs.existsSync(chartPath)) {
+    return createChart(taskId);
+  }
+  try {
+    return JSON.parse(fs.readFileSync(chartPath, 'utf8'));
+  } catch (e) {
+    throw new Error(`Failed to parse chart for ${taskId}: ${e.message}`);
+  }
+}
+
+function writeChart(chart) {
+  const chartPath = getChartPath(chart.task_id);
+  chartPathLib.ensureChartDir(chartPath);
+  chart.updated_at = new Date().toISOString();
+  fs.writeFileSync(chartPath, JSON.stringify(chart, null, 2), 'utf8');
+}
+
+// ═══════════════════════════════════════
+//  Module Loading
+// ═══════════════════════════════════════
+
+function loadModule(moduleName) {
+  const relPath = MODULE_PATHS[moduleName];
+  if (!relPath) {
+    return { name: moduleName, error: `Module '${moduleName}' not in MODULE_PATHS registry` };
+  }
+  const absPath = path.join(BASE_DIR, relPath);
+  if (!fs.existsSync(absPath)) {
+    return {
+      name: moduleName,
+      warning: `Module file not found: ${relPath} (expected after TASK_576)`,
+      content: null,
+    };
+  }
+  try {
+    const content = fs.readFileSync(absPath, 'utf8');
+    return { name: moduleName, path: relPath, content };
+  } catch (e) {
+    return { name: moduleName, error: `Failed to read ${relPath}: ${e.message}` };
+  }
+}
+
+/**
+ * Decide which modules to load for a given phase + chart context.
+ * Context-driven rules:
+ *   - fix_count >= 2 → inject loop_guard (prevent runaway fix loops)
+ */
+function decideModules(phase, chart) {
+  const modules = [...(PHASE_DEFAULT_MODULES[phase] || [])];
+
+  if (chart.vitals.fix_count >= 2 && !modules.includes('loop_guard')) {
+    modules.push('loop_guard');
+  }
+
+  // Deduplicate
+  return [...new Set(modules)];
+}
+
+
+// ═══════════════════════════════════════
+//  Phase Instruction Loader (TASK_583)
+// ═══════════════════════════════════════
+
+/**
+ * Extract a simple scalar value from YAML content.
+ * Handles:  key: "value"  or  key: value
+ */
+function extractScalar(content, key) {
+  const re = new RegExp(`^${key}:\\s*(.+?)\\s*$`, 'm');
+  const match = content.match(re);
+  if (!match) return null;
+  return match[1].replace(/^["']|["']$/g, '').trim();
+}
+
+/**
+ * Extract a block scalar (|) value from YAML content.
+ * Handles:  key: |\n    line1\n    line2
+ */
+function extractBlockScalar(content, key) {
+  // Find the block scalar header line
+  const headerRe = new RegExp(`^${key}:\\s*\\|[^\\n]*\\n`, 'm');
+  const headerMatch = content.match(headerRe);
+  if (!headerMatch) return null;
+
+  const startIdx = headerMatch.index + headerMatch[0].length;
+  const remaining = content.slice(startIdx).split('\n');
+
+  // Determine block indentation from first non-empty line
+  let blockIndent = null;
+  const blockLines = [];
+  for (const line of remaining) {
+    if (line.trim() === '') {
+      blockLines.push(''); // empty lines are part of the block
+      continue;
+    }
+    const indent = line.match(/^(\s*)/)[1].length;
+    if (blockIndent === null) blockIndent = indent;
+    if (indent < blockIndent) break; // dedented = end of block
+    blockLines.push(line);
+  }
+
+  // Strip trailing empty lines, then strip base indent
+  while (blockLines.length > 0 && blockLines[blockLines.length - 1] === '') blockLines.pop();
+  if (blockIndent === null) return null;
+  return blockLines.map(l => l === '' ? '' : l.slice(blockIndent)).join('\n');
+}
+
+/**
+ * Extract a block list from YAML content.
+ * Handles:  key:\n    - item1\n    - item2
+ */
+function extractBlockList(content, key) {
+  const re = new RegExp(`^${key}:\\s*\\n((?:[ \\t]+-[^\\n]*\\n?)*)`, 'm');
+  const match = content.match(re);
+  if (!match) return [];
+  return match[1].split('\n')
+    .map(l => l.trim())
+    .filter(l => l.startsWith('- '))
+    .map(l => l.slice(2).replace(/^["']|["']$/g, '').trim())
+    .filter(Boolean);
+}
+
+/**
+ * Extract context_hints.key_data from phase YAML content.
+ * Supports inline array: key_data: ["a", "b"]
+ * Supports block list: key_data:\n    - a\n    - b
+ * Supports null: key_data: null
+ */
+function extractKeyData(content) {
+  // Inline array: key_data: ["a", "b"]
+  const inlineMatch = content.match(/key_data:\s*\[([^\]]*)\]/);
+  if (inlineMatch) {
+    if (!inlineMatch[1].trim()) return [];
+    return inlineMatch[1].split(',')
+      .map(s => s.trim().replace(/^["']|["']$/g, ''))
+      .filter(Boolean);
+  }
+  // Null: key_data: null
+  if (/key_data:\s*null/.test(content)) return null;
+  // Block list under key_data (indented)
+  const blockMatch = content.match(/key_data:\s*\n((?:[ \t]+-[^\n]*\n?)*)/);
+  if (blockMatch) {
+    return blockMatch[1].split('\n')
+      .map(l => l.trim())
+      .filter(l => l.startsWith('- '))
+      .map(l => l.slice(2).replace(/^["']|["']$/g, '').trim())
+      .filter(Boolean);
+  }
+  return null;
+}
+
+/**
+ * Load phase YAML from phases/phase_N.yaml.
+ * Returns { content, name, goal, checklist, context_hints_raw, warning }
+ * Gracefully degrades if phases/ or the file doesn't exist.
+ */
+function loadPhaseInstructions(phase) {
+  if (!fs.existsSync(PHASES_DIR)) {
+    return {
+      content: null,
+      name: null,
+      goal: null,
+      checklist: [],
+      context_hints_raw: null,
+      warning: `phases/ directory not found — phase instructions unavailable (graceful degradation)`,
+    };
+  }
+  const phaseFile = path.join(PHASES_DIR, `phase_${phase}.yaml`);
+  if (!fs.existsSync(phaseFile)) {
+    return {
+      content: null,
+      name: null,
+      goal: null,
+      checklist: [],
+      context_hints_raw: null,
+      warning: `phase_${phase}.yaml not found — phase instructions unavailable`,
+    };
+  }
+  try {
+    const content = fs.readFileSync(phaseFile, 'utf8');
+    const name = extractScalar(content, 'name');
+    const goal = extractScalar(content, 'goal');
+    const checklist = extractBlockList(content, 'checklist');
+    const keyData = extractKeyData(content);
+    const inputFrom = extractScalar(content, 'input_from');
+    const poem = extractBlockScalar(content, 'poem');
+    return {
+      content,
+      name,
+      goal,
+      checklist,
+      poem: poem || null,
+      context_hints_raw: { key_data: keyData, input_from: inputFrom },
+      warning: null,
+    };
+  } catch (e) {
+    return {
+      content: null,
+      name: null,
+      goal: null,
+      checklist: [],
+      context_hints_raw: null,
+      warning: `Failed to read phase_${phase}.yaml: ${e.message}`,
+    };
+  }
+}
+
+/**
+ * Build context hints for phase N by reading the previous phase's data from chart.
+ * Reads context_hints.key_data from phase_N.yaml and extracts those keys from
+ * chart.phases[sourcePhasNum].data
+ * Returns { [key]: value, ... } or {}
+ */
+function buildContextHints(phase, chart, phaseInstructions, warnings) {
+  if (!phaseInstructions || !phaseInstructions.context_hints_raw) return {};
+  const { key_data, input_from } = phaseInstructions.context_hints_raw;
+  if (!key_data || key_data.length === 0) return {};
+
+  // Determine source phase number (default: phase - 1, overridden by input_from)
+  let sourcePhasNum = phase - 1;
+  if (input_from) {
+    const m = String(input_from).match(/(\d+)/);
+    if (m) sourcePhasNum = parseInt(m[1], 10);
+  }
+
+  const sourceData = (chart.phases[String(sourcePhasNum)] || {}).data || {};
+  const hints = {};
+  for (const key of key_data) {
+    hints[key] = key in sourceData ? sourceData[key] : null;
+  }
+
+  if (Object.keys(hints).length > 0 && Object.values(hints).every(v => v === null)) {
+    warnings.push(`context_hints: phase ${sourcePhasNum} data is empty — hints are null (agent may not have exited phase ${sourcePhasNum} yet)`);
+  }
+
+  const phase9Hints = buildPhase9VerificationHints(phase, sourceData, warnings);
+  if (phase9Hints) {
+    hints.verification_diff_strategy = phase9Hints;
+  }
+
+  return hints;
+}
+
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return null;
+}
+
+function branchFromExpected(expectedBranches, taskId, index) {
+  if (!expectedBranches) return null;
+  if (typeof expectedBranches === 'string') return expectedBranches.trim() || null;
+  if (Array.isArray(expectedBranches)) {
+    const candidate = expectedBranches[index];
+    return typeof candidate === 'string' && candidate.trim() ? candidate.trim() : null;
+  }
+  if (typeof expectedBranches === 'object') {
+    const candidate = taskId && typeof expectedBranches[taskId] === 'string'
+      ? expectedBranches[taskId]
+      : null;
+    return candidate && candidate.trim() ? candidate.trim() : null;
+  }
+  return null;
+}
+
+function buildPhase9VerificationHints(phase, sourceData, warnings) {
+  if (phase !== 9 || !sourceData || !Array.isArray(sourceData.dispatched_tasks)) return null;
+
+  const expectedBranches = sourceData.expected_branches;
+  const targets = sourceData.dispatched_tasks.map((task, index) => {
+    const taskObj = task && typeof task === 'object' ? task : {};
+    const taskId = firstNonEmptyString(taskObj.task_id, taskObj.id, taskObj.taskId, `task_${index + 1}`);
+    const branch = firstNonEmptyString(
+      taskObj.branch,
+      taskObj.branch_name,
+      taskObj.branchName,
+      taskObj.task_branch,
+      taskObj.taskBranch,
+      branchFromExpected(expectedBranches, taskId, index),
+    );
+    const commit = firstNonEmptyString(
+      taskObj.commit,
+      taskObj.commit_sha,
+      taskObj.commitSha,
+      taskObj.task_commit,
+      taskObj.taskCommit,
+      taskObj.head_commit,
+      taskObj.headCommit,
+      taskObj.head_sha,
+      taskObj.headSha,
+      taskObj.result && taskObj.result.commit,
+      taskObj.result && taskObj.result.commit_sha,
+      taskObj.result && taskObj.result.commitSha,
+    );
+    const baseBranch = firstNonEmptyString(
+      taskObj.base_branch,
+      taskObj.baseBranch,
+      taskObj.target_branch,
+      taskObj.targetBranch,
+      taskObj.user_branch,
+      taskObj.userBranch,
+      'main',
+    );
+
+    if (commit) {
+      return {
+        task_id: taskId,
+        strategy: 'single_commit',
+        command: `git show ${commit} --stat`,
+        branch,
+        commit,
+        rationale: 'Phase 9 should verify the task commit directly. HEAD..branch can pull in stale-base changes from the worktree and misreport the agent output.',
+      };
+    }
+
+    if (branch) {
+      return {
+        task_id: taskId,
+        strategy: 'three_dot',
+        command: `git diff ${baseBranch}...${branch} --stat`,
+        branch,
+        base_branch: baseBranch,
+        rationale: 'Fallback to three-dot diff when no task commit is recorded. The merge-base diff excludes unrelated history that HEAD..branch can over-report.',
+      };
+    }
+
+    warnings.push(`Phase 9: no commit or branch metadata found for dispatched task ${taskId} — verification diff hint omitted`);
+    return {
+      task_id: taskId,
+      strategy: 'unavailable',
+      command: null,
+      rationale: 'No task commit or branch metadata was recorded, so phase-gate could not build a safe verification diff command.',
+    };
+  });
+
+  return {
+    rationale: 'Prefer a single-commit view for Phase 9 verification. If only a branch is known, use a three-dot diff against the base branch instead of HEAD..branch.',
+    targets,
+  };
+}
+
+/**
+ * Extract inject configuration from phase YAML content.
+ * Parses nested inject: block with rules: and specialist: sub-lists.
+ *
+ * YAML schema:
+ *   inject:
+ *     rules:
+ *       - synapse-code-intelligence.yaml
+ *     specialist:
+ *       - capability.yaml#synapse_integration
+ *
+ * Returns { rules: string[], specialist: string[] }
+ */
+function extractInjectConfig(content) {
+  const result = { rules: [], specialist: [] };
+
+  const lines = content.split('\n');
+  let inInject = false;
+  const injectLines = [];
+
+  for (const line of lines) {
+    if (/^inject:\s*$/.test(line)) {
+      inInject = true;
+      continue;
+    }
+    if (inInject) {
+      // End inject block at next top-level key (non-whitespace start, non-empty)
+      if (line.length > 0 && !/^\s/.test(line)) break;
+      injectLines.push(line);
+    }
+  }
+
+  if (injectLines.length === 0) return result;
+
+  const injectBlock = injectLines.join('\n');
+
+  function parseSubList(block, key) {
+    const re = new RegExp(`^[ \\t]+${key}:[ \\t]*\\n((?:[ \\t]+-[^\\n]*\\n?)*)`, 'm');
+    const m = block.match(re);
+    if (!m) return [];
+    return m[1].split('\n')
+      .map(l => l.trim())
+      .filter(l => l.startsWith('- '))
+      .map(l => l.slice(2).replace(/^["']|["']$/g, '').trim())
+      .filter(Boolean);
+  }
+
+  result.rules = parseSubList(injectBlock, 'rules');
+  result.specialist = parseSubList(injectBlock, 'specialist');
+  return result;
+}
+
+/**
+ * Load injected rule/specialist files declared in a phase's inject config.
+ * Returns { [filename]: { path, content } | { path, error } }
+ */
+function loadInjectedFiles(injectConfig, warnings) {
+  const injected = {};
+
+  for (const ruleFile of injectConfig.rules) {
+    const relPath = path.join('.rule', 'general', ruleFile);
+    const absPath = path.join(BASE_DIR, relPath);
+    try {
+      const content = fs.readFileSync(absPath, 'utf8');
+      injected[ruleFile] = { path: relPath.replace(/\\/g, '/'), content };
+    } catch (e) {
+      injected[ruleFile] = { path: relPath.replace(/\\/g, '/'), error: `Failed to read: ${e.message}` };
+      warnings.push(`inject.rules: failed to load ${ruleFile}: ${e.message}`);
+    }
+  }
+
+  for (const specRef of injectConfig.specialist) {
+    // specRef may be "file.yaml" or "file.yaml#section"
+    const fileRef = specRef.split('#')[0];
+    const relPath = path.join('.specialist', 'Ansuz', fileRef);
+    const absPath = path.join(BASE_DIR, relPath);
+    try {
+      const content = fs.readFileSync(absPath, 'utf8');
+      injected[specRef] = { path: relPath.replace(/\\/g, '/'), content };
+    } catch (e) {
+      injected[specRef] = { path: relPath.replace(/\\/g, '/'), error: `Failed to read: ${e.message}` };
+      warnings.push(`inject.specialist: failed to load ${specRef}: ${e.message}`);
+    }
+  }
+
+  return injected;
+}
+
+/**
+ * Dump all phases from phases/ directory for debugging and documentation.
+ * node phase-gate.js dump --all
+ */
+function dumpPhases() {
+  if (!fs.existsSync(PHASES_DIR)) {
+    return outputResult({
+      action: 'dump',
+      warning: `phases/ directory not found at ${PHASES_DIR}`,
+      phases: [],
+    });
+  }
+
+  let files;
+  try {
+    files = fs.readdirSync(PHASES_DIR).filter(f => /^phase_\d+\.yaml$/.test(f));
+  } catch (e) {
+    return outputResult({ action: 'dump', error: `Failed to read phases/: ${e.message}`, phases: [] });
+  }
+
+  files.sort((a, b) => parseInt(a.match(/\d+/)[0]) - parseInt(b.match(/\d+/)[0]));
+
+  const phases = [];
+  for (const file of files) {
+    const phaseFile = path.join(PHASES_DIR, file);
+    try {
+      const content = fs.readFileSync(phaseFile, 'utf8');
+      const phaseNum = parseInt(file.match(/\d+/)[0]);
+      const name = extractScalar(content, 'name');
+      const goal = extractScalar(content, 'goal');
+      const checklist = extractBlockList(content, 'checklist');
+      phases.push({ phase: phaseNum, name, goal, checklist });
+    } catch (e) {
+      phases.push({ phase: parseInt(file.match(/\d+/)[0]), error: e.message });
+    }
+  }
+
+  return outputResult({ action: 'dump', total: phases.length, phases });
+}
+
+// ═══════════════════════════════════════
+//  Progress Note Helpers (TASK_579)
+// ═══════════════════════════════════════
+
+/**
+ * Search for a task YAML file by task ID.
+ * Checks both .collaboration/tasks/ and .kenaz/tasks/ directories.
+ */
+function findTaskFile(taskId) {
+  const searchRoots = [
+    path.join(BASE_DIR, '.collaboration', 'tasks'),
+    path.join(BASE_DIR, '.kenaz', 'tasks'),
+  ];
+  const statuses = ['active', 'done', 'backlog', 'blocked', 'cancel'];
+
+  for (const root of searchRoots) {
+    if (!fs.existsSync(root)) continue;
+    for (const status of statuses) {
+      const dir = path.join(root, status);
+      if (!fs.existsSync(dir)) continue;
+      try {
+        const files = fs.readdirSync(dir);
+        const match = files.find(f => f.startsWith(taskId + '_') || f === taskId + '.yaml');
+        if (match) return path.join(dir, match);
+      } catch { /* skip */ }
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract a YAML list field from raw file content (no external deps).
+ * Handles:  field_name:
+ *             - item 1
+ */
+function extractYamlList(content, fieldName) {
+  const escaped = fieldName.replace(/[.*+?^${}()|[\]\\]/g, String.raw`// ═══════════════════════════════════════
+//  Enter Logic
+// ═══════════════════════════════════════`);
+  const blockRe = new RegExp(escaped + ':[ \\t]*\\n((?:[ \\t]+-[^\\n]*\\n?)*)', 'm');
+  const match = content.match(blockRe);
+  if (!match) return [];
+  return match[1].split('\n').map(line => line.trim()).filter(line => line.startsWith('- ')).map(line => line.slice(2).replace(/^['"]|['"]$/g, '').trim()).filter(Boolean);
+}
+
+function readTaskScopePaths(taskId) {
+  try {
+    const file = findTaskFile(taskId);
+    if (!file) return [];
+    const raw = fs.readFileSync(file, 'utf8');
+    return extractYamlList(raw, 'scope_paths');
+  } catch {
+    return [];
+  }
+}
+
+function findActiveOrBacklogTaskFile(taskId) {
+  const tasksRoot = resolveKenazPath('tasks');
+  for (const status of ['active', 'backlog']) {
+    const dir = path.join(tasksRoot, status);
+    if (!fs.existsSync(dir)) continue;
+    try {
+      const files = fs.readdirSync(dir);
+      const match = files.find(f => f.startsWith(taskId + '_') || f === taskId + '.yaml');
+      if (match) return path.join(dir, match);
+    } catch { /* skip unreadable task dirs */ }
+  }
+  return null;
+}
+
+function extractYamlScalar(content, fieldName) {
+  const escaped = fieldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`^${escaped}:[ \\t]*(.*?)\\s*$`, 'm');
+  const match = content.match(re);
+  if (!match) return null;
+  const value = match[1].replace(/^['"]|['"]$/g, '').trim();
+  return value.length > 0 ? value : null;
+}
+
+function readTaskForCompressionFallback(taskId, warnings) {
+  const file = findActiveOrBacklogTaskFile(taskId);
+  if (!file) {
+    warnings.push(`Phase 8 compression_fallback: task YAML not found for ${taskId} in active/backlog — skipped`);
+    return null;
+  }
+
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+    const scopePaths = extractYamlList(raw, 'scope_paths');
+    if (scopePaths.length === 0) {
+      warnings.push(`Phase 8 compression_fallback: task ${taskId} has no scope_paths — skipped`);
+      return null;
+    }
+
+    const dependencyList = extractYamlList(raw, 'dependencies');
+    const dependencyScalar = extractYamlScalar(raw, 'dependencies');
+    return {
+      task_id: taskId,
+      scope_paths: scopePaths,
+      rigor: extractYamlScalar(raw, 'rigor') || 'medium',
+      dependencies: dependencyList.length > 0
+        ? dependencyList
+        : (dependencyScalar && dependencyScalar !== 'null' ? [dependencyScalar] : []),
+    };
+  } catch (e) {
+    warnings.push(`Phase 8 compression_fallback: failed to read task YAML for ${taskId}: ${e.message}`);
+    return null;
+  }
+}
+
+function readProjectYaml() {
+  const projectYamlPath = resolveKenazPath('project.yaml');
+  if (!fs.existsSync(projectYamlPath)) return null;
+  try {
+    return fs.readFileSync(projectYamlPath, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+function isPhase0GitContextDisabled(projectYamlContent) {
+  if (!projectYamlContent || typeof projectYamlContent !== 'string') return false;
+  const phase0Match = projectYamlContent.match(/^phase0:\s*\n((?:[ \t]+[^\n]*\n?)*)/m);
+  if (!phase0Match) return false;
+  return /^[ \t]+git_context:\s*disabled\s*$/m.test(phase0Match[1]);
+}
+
+function getChartPhaseRecord(chart, phase) {
+  const key = String(phase);
+  return (chart && chart.phases && chart.phases[key]) || (chart && chart[`phase_${key}`]) || null;
+}
+
+function getPhaseData(phaseRecord) {
+  return phaseRecord && phaseRecord.data && typeof phaseRecord.data === 'object'
+    ? phaseRecord.data
+    : {};
+}
+
+function hasPredictionForTask(taskId) {
+  try {
+    if (!fs.existsSync(PREDICTIONS_PATH)) return false;
+    const parsed = JSON.parse(fs.readFileSync(PREDICTIONS_PATH, 'utf8'));
+    return !!(parsed && Array.isArray(parsed.predictions) &&
+      parsed.predictions.some(p => p && p.task_id === taskId));
+  } catch {
+    return false;
+  }
+}
+
+function shouldWriteCompressionFallback(chart, taskId) {
+  if (!taskId) return false;
+  const phase3 = getChartPhaseRecord(chart, 3);
+  const phase3Data = getPhaseData(phase3);
+
+  if (phase3Data.design_inputs_recorded === true || (phase3 && phase3.design_inputs_recorded === true)) return false;
+  if (phase3 && phase3Data.predictions_recorded && Number(phase3Data.predictions_recorded) > 0) return false;
+  if (phase3 && phase3.predictions_recorded && Number(phase3.predictions_recorded) > 0) return false;
+
+  return !hasPredictionForTask(taskId);
+}
+
+function emitCompressionFallbackIfNeeded(chart, taskId, warnings) {
+  if (!shouldWriteCompressionFallback(chart, taskId)) return false;
+
+  const task = readTaskForCompressionFallback(taskId, warnings);
+  if (!task) return false;
+
+  writePredictions([{
+    task_id: taskId,
+    scope_paths: task.scope_paths,
+    risk: task.rigor,
+    source: 'compression_fallback',
+    confidence: 0.5,
+    predicted_health_delta: null,
+  }], warnings);
+
+  try {
+    const dr = require(path.join(BASE_DIR, '.specialist', 'tools', 'design-reasoning.js'));
+    dr.recordDesignReasoning({
+      taskId,
+      principlesApplied: [],
+      guardsApplied: [],
+      formationSelected: 'compression_fallback',
+      subtaskCount: 1,
+      splitRationale: null,
+      dependencyAssumptions: task.dependencies,
+      riskAssessment: task.rigor,
+      notes: 'synthesized at Phase 8 enter — Phase 3 was compressed',
+      source: 'compression_fallback',
+    });
+  } catch (e) {
+    warnings.push(`Phase 8 compression_fallback: failed to record design reasoning: ${e.message}`);
+  }
+
+  warnings.push(`Phase 8 compression_fallback: synthesized minimal prediction for ${taskId}`);
+  return true;
+}
+
+/**
+ * Count word overlap between two strings (case-insensitive, for fuzzy AC matching).
+ */
+function wordOverlap(a, b) {
+  const stopWords = new Set(['the','a','an','is','are','to','of','and','in','for','on','at','by','with','from']);
+  const tokenize = s => s.toLowerCase().replace(/[^a-z0-9\s]/g, ' ').split(/\s+/).filter(w => w.length > 2 && !stopWords.has(w));
+  const wordsA = new Set(tokenize(a));
+  const wordsB = tokenize(b);
+  return wordsB.filter(w => wordsA.has(w)).length;
+}
+
+/**
+ * Validate progress notes in a chart against task acceptance_criteria + scope_paths.
+ * Returns structured result embedded in Phase 9 data.
+ * Non-blocking: scope_violations and cognitive_gap produce warnings only.
+ *
+ * @param {object} chart - parsed chart JSON
+ * @param {string} taskId - task ID
+ * @returns {{ validation: object, warnings: string[] }}
+ */
+function validateProgressNotes(chart, taskId) {
+  const warnings = [];
+  const notes = chart.progress_notes || [];
+
+  if (notes.length === 0) {
+    return {
+      validation: {
+        ac_pass_count: 0, ac_fail_count: 0, ac_partial_count: 0,
+        ac_unmatched: [], scope_violations: [], deviations: [],
+        cognitive_gap: false, note_count: 0, skipped: true,
+        skip_reason: 'No progress notes found in chart',
+      },
+      warnings: ['Phase 9: No progress_notes in chart — agent may not have written a progress note'],
+    };
+  }
+
+  const taskFile = findTaskFile(taskId);
+  let taskAcceptanceCriteria = [];
+  let taskScopePaths = [];
+
+  if (taskFile) {
+    try {
+      const yamlContent = fs.readFileSync(taskFile, 'utf8');
+      taskAcceptanceCriteria = extractYamlList(yamlContent, 'acceptance_criteria');
+      taskScopePaths = extractYamlList(yamlContent, 'scope_paths');
+    } catch (e) {
+      warnings.push(`Phase 9: Failed to read task YAML at ${taskFile}: ${e.message}`);
+    }
+  } else {
+    warnings.push(`Phase 9: Task YAML not found for ${taskId} — AC comparison skipped`);
+  }
+
+  let acPassCount = 0;
+  let acFailCount = 0;
+  let acPartialCount = 0;
+  const acUnmatched = [];
+  const allScopeViolations = [];
+  const allDeviations = [];
+  let cognitiveGap = false;
+
+  for (const note of notes) {
+    const noteAC = Array.isArray(note.acceptance_criteria) ? note.acceptance_criteria : [];
+
+    if (taskAcceptanceCriteria.length > 0) {
+      for (const taskCriterion of taskAcceptanceCriteria) {
+        let bestMatch = null;
+        let bestScore = 0;
+        for (const noteEntry of noteAC) {
+          const criterion = noteEntry.criterion || '';
+          if (criterion.toLowerCase().includes(taskCriterion.toLowerCase().slice(0, 20))) {
+            bestMatch = noteEntry; bestScore = 999; break;
+          }
+          const score = wordOverlap(taskCriterion, criterion);
+          if (score > bestScore) { bestScore = score; bestMatch = noteEntry; }
+        }
+        if (bestMatch && bestScore >= 3) {
+          const status = (bestMatch.status || '').toLowerCase();
+          if (status === 'pass') acPassCount++;
+          else if (status === 'fail') acFailCount++;
+          else if (status === 'partial') acPartialCount++;
+          else acUnmatched.push(taskCriterion);
+        } else {
+          acUnmatched.push(taskCriterion);
+        }
+      }
+    } else {
+      for (const entry of noteAC) {
+        const status = (entry.status || '').toLowerCase();
+        if (status === 'pass') acPassCount++;
+        else if (status === 'fail') acFailCount++;
+        else if (status === 'partial') acPartialCount++;
+      }
+    }
+
+    if (taskScopePaths.length > 0) {
+      const changes = note.changes || {};
+      const allFiles = [
+        ...(changes.files_created || []),
+        ...(changes.files_modified || []),
+        ...(changes.files_deleted || []),
+      ];
+      for (const file of allFiles) {
+        const normalFile = file.replace(/\\/g, '/');
+        const inScope = taskScopePaths.some(sp => {
+          const normalSp = sp.replace(/\\/g, '/').replace(/\/$/, '');
+          return normalFile.startsWith(normalSp + '/') || normalFile === normalSp;
+        });
+        if (!inScope && !allScopeViolations.includes(normalFile)) {
+          allScopeViolations.push(normalFile);
+        }
+      }
+    }
+
+    const noteDeviations = note.deviations || [];
+    for (const d of noteDeviations) {
+      if (d && !allDeviations.includes(d)) allDeviations.push(d);
+    }
+
+    const cogOut = note.cognitive_output || {};
+    const runes = cogOut.runes || [];
+    const sigils = cogOut.sigils || [];
+    if (runes.length === 0 && sigils.length === 0) cognitiveGap = true;
+  }
+
+  if (allScopeViolations.length > 0) {
+    warnings.push(`Phase 9: scope_violations — agent modified files outside scope_paths: [${allScopeViolations.join(', ')}]. Ansuz should verify.`);
+  }
+  if (cognitiveGap) {
+    warnings.push('Phase 9: cognitive_gap — no runes/sigils inscribed. Ansuz should evaluate if synapse_inscribe is warranted.');
+  }
+  if (acUnmatched.length > 0) {
+    warnings.push(`Phase 9: ${acUnmatched.length} AC item(s) could not be matched in progress note.`);
+  }
+
+  return {
+    validation: {
+      ac_pass_count: acPassCount,
+      ac_fail_count: acFailCount,
+      ac_partial_count: acPartialCount,
+      ac_unmatched: acUnmatched,
+      scope_violations: allScopeViolations,
+      deviations: allDeviations,
+      cognitive_gap: cognitiveGap,
+      note_count: notes.length,
+      skipped: false,
+    },
+    warnings,
+  };
+}
+// ═══════════════════════════════════════
+//  Hippocampus Integration (TASK_618)
+// ═══════════════════════════════════════
+
+/**
+ * Call hippocampus_episode_recall via MCP HTTP API (port 18080).
+ * Graceful degradation: returns null if Hippocampus MCP is unavailable.
+ * @param {string} taskId - TASK_XXX
+ * @param {string|null} [agentRole] - Optional agent_role filter (e.g. 'ansuz', 'amelia').
+ *   When provided, only episodes for that specialist are returned.
+ *   When null, all episodes returned (backwards compatible — legacy episodes have agent_role='pm').
+ * @returns {{ episodes: object[], formatted: string } | null}
+ */
+function recallEpisodicMemory(taskId, agentRole = null) {
+  // With task_id: recall episodes for that specific task
+  // Without task_id (or "none"): recall the most recent 1 episode (new Ansuz session context)
+  const hasTask = taskId && taskId !== 'none';
+  const recallArgs = hasTask
+    ? { task_id: taskId, limit: 5 }
+    : { limit: 3 };
+  if (agentRole) recallArgs.agent_role = agentRole;
+  // TASK_1983 (R4): explicit project — without this, the call silently follows
+  // the Dashboard's currently-selected project (feedback_mcp_default_project_drift).
+  recallArgs.projectPath = resolveHandoffProjectRoot();
+
+  const script = `
+    const http = require('http');
+    const payload = JSON.stringify({
+      jsonrpc: '2.0', id: 1,
+      method: 'tools/call',
+      params: { name: 'hippocampus_episode_recall', arguments: ${JSON.stringify(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 d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => process.stdout.write(d));
+    });
+    req.on('error', () => process.exit(0));
+    req.on('timeout', () => { req.destroy(); process.exit(0); });
+    req.write(payload);
+    req.end();
+  `;
+
+  try {
+    const stdout = execFileSync(process.execPath, ['-e', script], {
+      timeout: 8000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true,
+    });
+    if (!stdout || !stdout.trim()) return null;
+
+    const result = JSON.parse(stdout);
+    if (!result || result.error) return null;
+
+    const content = result.result?.content;
+    if (!content || !Array.isArray(content)) return null;
+
+    const textPart = content.find(c => c.type === 'text');
+    if (!textPart || !textPart.text) return null;
+
+    const data = JSON.parse(textPart.text);
+    const episodes = data.episodes || [];
+    if (episodes.length === 0) return null;
+
+    // Format episodes as ## Episodic Memory section
+    const lines = ['## Episodic Memory (from Hippocampus)', ''];
+    const context = hasTask ? taskId : 'recent session';
+    lines.push(`Found ${episodes.length} episode(s) for ${context}:`);
+    lines.push('');
+
+    for (const ep of episodes) {
+      const epData = ep.episode || ep;  // hippocampus returns { episode: {...}, entries: [...] }
+      lines.push(`### Episode: ${epData.task_id || epData.id || 'unknown'}`);
+      if (epData.summary) lines.push(`Summary: ${epData.summary}`);
+      if (epData.lesson) lines.push(`Lesson: ${epData.lesson}`);
+      lines.push('');
+    }
+    lines.push('(Use hippocampus_episode_recall for full entry detail if needed)')
+
+    return { episodes, formatted: lines.join('\n') };
+  } catch {
+    return null; // graceful degradation — Hippocampus MCP unavailable
+  }
+}
+
+function parseIsoDate(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+
+function countStatMatches(raw, pattern) {
+  const match = String(raw || '').match(pattern);
+  return match ? Number.parseInt(match[1], 10) || 0 : 0;
+}
+
+function parseGitDiffStat(raw) {
+  const text = String(raw || '').trim();
+  return {
+    files_changed: countStatMatches(text, /(\d+)\s+files?\s+changed/),
+    insertions: countStatMatches(text, /(\d+)\s+insertions?\(\+\)/),
+    deletions: countStatMatches(text, /(\d+)\s+deletions?\(-\)/),
+  };
+}
+
+function readLastAnsuzSessionClosedAt(projectPath, warnings) {
+  const recallArgs = {
+    limit: 10,
+    projectPath,
+    agent_role: 'ansuz',
+    outcome: 'closed',
+    sort: 'closed_at_desc',
+  };
+
+  const script = `
+    const http = require('http');
+    const payload = JSON.stringify({
+      jsonrpc: '2.0', id: 1,
+      method: 'tools/call',
+      params: { name: 'hippocampus_episode_recall', arguments: ${JSON.stringify(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 d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => process.stdout.write(d));
+    });
+    req.on('error', () => process.exit(0));
+    req.on('timeout', () => { req.destroy(); process.exit(0); });
+    req.write(payload);
+    req.end();
+  `;
+
+  try {
+    const stdout = execFileSync(process.execPath, ['-e', script], {
+      timeout: 8000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true,
+    });
+    if (!stdout || !stdout.trim()) return null;
+
+    const result = JSON.parse(stdout);
+    if (!result || result.error) return null;
+
+    const content = result.result?.content;
+    if (!content || !Array.isArray(content)) return null;
+
+    const textPart = content.find(c => c.type === 'text');
+    if (!textPart || !textPart.text) return null;
+
+    const data = JSON.parse(textPart.text);
+    const episodes = Array.isArray(data.episodes) ? data.episodes : [];
+    if (episodes.length === 0) return null;
+
+    const sorted = episodes
+      .map((episode) => episode && typeof episode === 'object' ? (episode.episode || episode) : null)
+      .filter(Boolean)
+      .filter((episode) => {
+        const role = String(episode.agent_role || '').toLowerCase();
+        const outcome = String(episode.outcome || '').toLowerCase();
+        return role === 'ansuz' && outcome !== '' && outcome !== 'open';
+      })
+      .map((episode) => ({ episode, closedAt: parseIsoDate(episode.closed_at) }))
+      .filter((item) => item.closedAt !== null)
+      .sort((a, b) => b.closedAt.getTime() - a.closedAt.getTime());
+
+    if (sorted.length === 0) return null;
+    return sorted[0].closedAt.toISOString();
+  } catch (error) {
+    if (Array.isArray(warnings)) {
+      warnings.push(`git_context: hippocampus_episode_recall unavailable, using fallback_24h (${error.message})`);
+    }
+    return null;
+  }
+}
+
+function resolveGitContextSince(projectPath, warnings) {
+  const now = new Date();
+  const fallback = new Date(now.getTime() - (24 * 60 * 60 * 1000));
+  const lastClosedAtIso = readLastAnsuzSessionClosedAt(projectPath, warnings);
+  const lastClosedAt = parseIsoDate(lastClosedAtIso);
+
+  if (!lastClosedAt) {
+    return {
+      since_iso: fallback.toISOString(),
+      since_source: 'fallback_24h',
+    };
+  }
+
+  return {
+    since_iso: lastClosedAt.toISOString(),
+    since_source: 'last_session',
+  };
+}
+
+function loadGitContext(projectPath, since_iso) {
+  if (!projectPath || !since_iso) return null;
+  if (!fs.existsSync(path.join(projectPath, '.git'))) return null;
+
+  try {
+    const logStdout = execFileSync(
+      'git',
+      ['log', '--oneline', `--since=${since_iso}`, '-n', '10', '--pretty=format:%h\t%s\t%aI'],
+      { cwd: projectPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true }
+    );
+    const diffStdout = execFileSync(
+      'git',
+      ['diff', '--stat', 'HEAD'],
+      { cwd: projectPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true }
+    );
+
+    const recent_commits = String(logStdout || '')
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => {
+        const [hash, subject, author_time] = line.split('\t');
+        if (!hash || !subject || !author_time) return null;
+        return { hash, subject, author_time };
+      })
+      .filter(Boolean);
+
+    return {
+      recent_commits,
+      wt_diff_stat: parseGitDiffStat(diffStdout),
+      since_iso,
+      since_source: 'unknown',
+    };
+  } catch {
+    return null;
+  }
+}
+
+function readGitContext(projectPath, warnings) {
+  const projectYaml = readProjectYaml();
+  if (isPhase0GitContextDisabled(projectYaml)) return null;
+  if (!fs.existsSync(path.join(projectPath, '.git'))) return null;
+
+  const since = resolveGitContextSince(projectPath, warnings);
+  const gitContext = loadGitContext(projectPath, since.since_iso);
+  if (!gitContext) return null;
+
+  gitContext.since_source = since.since_source;
+  return gitContext;
+}
+
+// ═══════════════════════════════════════
+//  User Model — Language + Profile Injection (TASK_1041)
+// ═══════════════════════════════════════
+
+/**
+ * Detect preferred language from OS locale. Falls back to 'en' when no signal.
+ * Priority: LANG → LC_ALL → Intl.DateTimeFormat resolvedOptions().locale.
+ * Maps zh-prefix/Hans/Hant to 'zh'; everything else to 'en'.
+ * @returns {string} 'zh' | 'en'
+ */
+function detectOSLocale() {
+  const candidates = [];
+  if (process.env.LANG) candidates.push(String(process.env.LANG));
+  if (process.env.LC_ALL) candidates.push(String(process.env.LC_ALL));
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+    if (locale) candidates.push(String(locale));
+  } catch {
+    // Intl unavailable (should not happen on Node >= 13) — skip.
+  }
+  for (const c of candidates) {
+    if (/zh|Hans|Hant/i.test(c)) return 'zh';
+  }
+  return 'en';
+}
+
+/**
+ * Read user_model.json from .kenaz/ and derive a compact summary for Phase 0 injection.
+ * On missing file: returns {loaded:false, preferred_language:<os-locale>, source:'os_locale'}.
+ * On JSON parse failure: pushes a warning, returns {loaded:false, preferred_language:<os-locale>, source:'os_locale'}.
+ * On success: returns {loaded:true, preferred_language:<file>, source:'file', schema_version, last_updated, model}.
+ * Source values: 'file' | 'os_locale' | 'default'.
+ * @param {string} basePath - Project root (typically BASE_DIR).
+ * @param {string[]} warnings - Mutable warnings collector from enterPhase.
+ * @returns {object}
+ */
+function readUserModel(basePath, warnings) {
+  const filePath = path.join(basePath, '.kenaz', 'user_model.json');
+  if (!fs.existsSync(filePath)) {
+    return {
+      loaded: false,
+      preferred_language: detectOSLocale(),
+      source: 'os_locale',
+      schema_version: null,
+      last_updated: null,
+      model: null,
+    };
+  }
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const lang = (parsed && parsed.communication && typeof parsed.communication.preferred_language === 'string')
+      ? parsed.communication.preferred_language
+      : null;
+    if (!lang) {
+      return {
+        loaded: true,
+        preferred_language: detectOSLocale(),
+        source: 'os_locale',
+        schema_version: parsed.schema_version || null,
+        last_updated: parsed.last_updated || null,
+        model: parsed,
+      };
+    }
+    return {
+      loaded: true,
+      preferred_language: lang,
+      source: 'file',
+      schema_version: parsed.schema_version || null,
+      last_updated: parsed.last_updated || null,
+      model: parsed,
+    };
+  } catch (e) {
+    if (Array.isArray(warnings)) {
+      warnings.push(`USER_MODEL: .kenaz/user_model.json parse failed (${e.message}) — falling back to OS locale`);
+    }
+    return {
+      loaded: false,
+      preferred_language: detectOSLocale(),
+      source: 'os_locale',
+      schema_version: null,
+      last_updated: null,
+      model: null,
+    };
+  }
+}
+
+function getUserProfilePath() {
+  return path.join(os.homedir(), '.kenaz', 'user_profile.json');
+}
+
+function readUserProfile(warnings) {
+  const filePath = getUserProfilePath();
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (e) {
+    if (Array.isArray(warnings)) {
+      warnings.push(`USER_PROFILE: ~/.kenaz/user_profile.json parse failed (${e.message})`);
+    }
+    return null;
+  }
+}
+
+function readUserObservations(days = 30, warnings) {
+  if (!fs.existsSync(USER_OBSERVATIONS_PATH)) {
+    return { loaded: false, observations: [] };
+  }
+
+  const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+  try {
+    const raw = fs.readFileSync(USER_OBSERVATIONS_PATH, 'utf8');
+    const observations = raw
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => {
+        try { return JSON.parse(line); } catch { return null; }
+      })
+      .filter(Boolean)
+      .filter((entry) => {
+        const ts = new Date(entry.timestamp).getTime();
+        return Number.isFinite(ts) && ts >= cutoff;
+      });
+    return { loaded: true, observations };
+  } catch (e) {
+    if (Array.isArray(warnings)) {
+      warnings.push(`USER_OBSERVATIONS: read failed (${e.message})`);
+    }
+    return { loaded: false, observations: [] };
+  }
+}
+
+function computeSignalRateTrend(recentCount, previousCount, recentDays, previousDays) {
+  const recentRate = recentDays > 0 ? recentCount / recentDays : 0;
+  const previousRate = previousDays > 0 ? previousCount / previousDays : 0;
+  if (recentCount === 0 && previousCount === 0) return { trend: 'stable', recentRate, previousRate };
+  if (recentRate >= previousRate * 1.35 + 0.01) return { trend: 'increasing', recentRate, previousRate };
+  if (previousRate >= recentRate * 1.35 + 0.01) return { trend: 'decreasing', recentRate, previousRate };
+  return { trend: 'stable', recentRate, previousRate };
+}
+
+function summarizeCommunicationWindow(entries) {
+  const summary = {
+    messageCount: 0,
+    totalChars: 0,
+    langCounts: { zh: 0, en: 0, mixed: 0 },
+    avgLength: 0,
+    dominantLanguage: null,
+  };
+
+  for (const entry of entries) {
+    if (entry.signal_type !== 'communication_meta' || !entry.batch) continue;
+    const messages = entry.batch.messages || 0;
+    const totalChars = entry.batch.total_chars || 0;
+    summary.messageCount += messages;
+    summary.totalChars += totalChars;
+    for (const lang of ['zh', 'en', 'mixed']) {
+      summary.langCounts[lang] += (entry.batch.lang_counts && entry.batch.lang_counts[lang]) || 0;
+    }
+  }
+
+  if (summary.messageCount > 0) {
+    summary.avgLength = Math.round(summary.totalChars / summary.messageCount);
+    const dominant = Object.entries(summary.langCounts).sort((a, b) => b[1] - a[1])[0];
+    summary.dominantLanguage = dominant && dominant[1] > 0 ? dominant[0] : null;
+  }
+
+  return summary;
+}
+
+function ratioDelta(lang, recentSummary, previousSummary) {
+  const recentRatio = recentSummary.messageCount > 0
+    ? recentSummary.langCounts[lang] / recentSummary.messageCount
+    : 0;
+  const previousRatio = previousSummary.messageCount > 0
+    ? previousSummary.langCounts[lang] / previousSummary.messageCount
+    : 0;
+  return {
+    recent: recentRatio,
+    previous: previousRatio,
+    delta: recentRatio - previousRatio,
+  };
+}
+
+function buildDynamicUserContext(warnings) {
+  const windowDays = 30;
+  const recentDays = 7;
+  const previousDays = windowDays - recentDays;
+  const observationResult = readUserObservations(windowDays, warnings);
+  const userProfile = readUserProfile(warnings);
+
+  if (!observationResult.loaded || observationResult.observations.length === 0) {
+    return {
+      loaded: observationResult.loaded,
+      observation_count: 0,
+      window_days: windowDays,
+      significant_change_detected: false,
+      insight_lines: [],
+      summary: null,
+      correction_trend: { trend: 'stable', recent_count: 0, previous_count: 0, recent_rate: 0, previous_rate: 0 },
+      domain_shift: { new_domains: [], recent_domains: [], known_domains: userProfile?.expertise ? Object.keys(userProfile.expertise) : [] },
+      communication_shift: {
+        language_ratio_shift: { changed: false, previous_dominant: null, recent_dominant: null, deltas: { zh: 0, en: 0, mixed: 0 } },
+        message_length_trend: { trend: 'stable', recent_avg: 0, previous_avg: 0 },
+      },
+    };
+  }
+
+  const splitTime = Date.now() - recentDays * 24 * 60 * 60 * 1000;
+  const recent = [];
+  const previous = [];
+  for (const entry of observationResult.observations) {
+    const ts = new Date(entry.timestamp).getTime();
+    if (!Number.isFinite(ts)) continue;
+    if (ts >= splitTime) recent.push(entry);
+    else previous.push(entry);
+  }
+
+  const recentCorrections = recent.filter((e) => e.signal_type === 'correction').length;
+  const previousCorrections = previous.filter((e) => e.signal_type === 'correction').length;
+  const correctionRates = computeSignalRateTrend(recentCorrections, previousCorrections, recentDays, previousDays);
+
+  const recentDomains = [...new Set(recent.map((e) => e.domain).filter(Boolean))].sort();
+  const previousDomains = new Set(previous.map((e) => e.domain).filter(Boolean));
+  const knownDomains = new Set(Object.keys(userProfile?.expertise || {}));
+  const newDomains = recentDomains.filter((domain) => !previousDomains.has(domain) && !knownDomains.has(domain));
+
+  const recentComm = summarizeCommunicationWindow(recent);
+  const previousComm = summarizeCommunicationWindow(previous);
+  const languageDeltas = {
+    zh: ratioDelta('zh', recentComm, previousComm),
+    en: ratioDelta('en', recentComm, previousComm),
+    mixed: ratioDelta('mixed', recentComm, previousComm),
+  };
+  const languageShiftChanged =
+    recentComm.dominantLanguage !== previousComm.dominantLanguage ||
+    Object.values(languageDeltas).some((d) => Math.abs(d.delta) >= 0.2);
+
+  const lengthTrend = (() => {
+    if (recentComm.messageCount === 0 || previousComm.messageCount === 0) {
+      return { trend: 'stable', recent_avg: recentComm.avgLength, previous_avg: previousComm.avgLength };
+    }
+    if (recentComm.avgLength >= previousComm.avgLength * 1.15 + 20) {
+      return { trend: 'longer', recent_avg: recentComm.avgLength, previous_avg: previousComm.avgLength };
+    }
+    if (previousComm.avgLength >= recentComm.avgLength * 1.15 + 20) {
+      return { trend: 'shorter', recent_avg: recentComm.avgLength, previous_avg: previousComm.avgLength };
+    }
+    return { trend: 'stable', recent_avg: recentComm.avgLength, previous_avg: previousComm.avgLength };
+  })();
+
+  const insightLines = [];
+  if (correctionRates.trend === 'increasing' && recentCorrections > 0) {
+    insightLines.push(`User corrections are increasing this week (${recentCorrections} recent vs ${previousCorrections} earlier in the month).`);
+  } else if (correctionRates.trend === 'decreasing' && previousCorrections > 0) {
+    insightLines.push(`User corrections are easing this week (${recentCorrections} recent vs ${previousCorrections} earlier in the month).`);
+  }
+  if (newDomains.length > 0) {
+    insightLines.push(`New user focus domains appeared recently: ${newDomains.slice(0, 3).join(', ')}.`);
+  } else if (languageShiftChanged) {
+    insightLines.push(`Communication style shifted recently (${previousComm.dominantLanguage || 'none'} → ${recentComm.dominantLanguage || 'none'}).`);
+  } else if (lengthTrend.trend !== 'stable') {
+    insightLines.push(`Recent user messages are trending ${lengthTrend.trend} (${lengthTrend.previous_avg} → ${lengthTrend.recent_avg} chars avg).`);
+  }
+
+  return {
+    loaded: true,
+    observation_count: observationResult.observations.length,
+    window_days: windowDays,
+    significant_change_detected: insightLines.length > 0,
+    insight_lines: insightLines.slice(0, 2),
+    summary: insightLines.slice(0, 2).join(' '),
+    correction_trend: {
+      trend: correctionRates.trend,
+      recent_count: recentCorrections,
+      previous_count: previousCorrections,
+      recent_rate: Number(correctionRates.recentRate.toFixed(3)),
+      previous_rate: Number(correctionRates.previousRate.toFixed(3)),
+    },
+    domain_shift: {
+      new_domains: newDomains,
+      recent_domains: recentDomains,
+      known_domains: [...knownDomains].sort(),
+    },
+    communication_shift: {
+      language_ratio_shift: {
+        changed: languageShiftChanged,
+        previous_dominant: previousComm.dominantLanguage,
+        recent_dominant: recentComm.dominantLanguage,
+        deltas: {
+          zh: Number(languageDeltas.zh.delta.toFixed(3)),
+          en: Number(languageDeltas.en.delta.toFixed(3)),
+          mixed: Number(languageDeltas.mixed.delta.toFixed(3)),
+        },
+      },
+      message_length_trend: lengthTrend,
+    },
+  };
+}
+
+/**
+ * Call an MCP tool through the local Dashboard HTTP bridge.
+ * Returns parsed tool text payload as JSON, or null on any failure.
+ * Graceful degradation is intentional for Phase 0 boot.
+ * @param {string} toolName
+ * @param {object} args
+ * @returns {object|null}
+ */
+function callMcpTool(toolName, args = {}) {
+  const script = `
+    const http = require('http');
+    const fs = require('fs');
+    const input = JSON.parse(fs.readFileSync(0, 'utf8'));
+    const payload = JSON.stringify({
+      jsonrpc: '2.0', id: 1,
+      method: 'tools/call',
+      params: { name: input.toolName, arguments: input.args }
+    });
+    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 d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => process.stdout.write(d));
+    });
+    req.on('error', () => process.exit(0));
+    req.on('timeout', () => { req.destroy(); process.exit(0); });
+    req.write(payload);
+    req.end();
+  `;
+
+  try {
+    const stdout = execFileSync(process.execPath, ['-e', script], {
+      input: JSON.stringify({ toolName, args }),
+      timeout: 8000, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true,
+    });
+    if (!stdout || !stdout.trim()) return null;
+
+    const result = JSON.parse(stdout);
+    if (!result || result.error) return null;
+
+    const content = result.result?.content;
+    if (!content || !Array.isArray(content)) return null;
+
+    const textPart = content.find(c => c.type === 'text');
+    if (!textPart || !textPart.text) return null;
+
+    return JSON.parse(textPart.text);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Auto-restore active session handoff during Phase 0.
+ * Reads active slot, archives it to Hippocampus, then deletes the slot.
+ * Returns a compact summary for Phase 0 banner rendering.
+ * Graceful degradation: on archive failure, keep the slot for the next session.
+ * @param {string[]} warnings
+ * @returns {{loaded:boolean, summary?:object|null, retained?:boolean}}
+ */
+function restoreSessionHandoff(warnings) {
+  // TASK_1829: this is a LEGACY-slot back-compat consume/cleanup path only.
+  // The singular slot was retired by M3 (TASK_1760) and normally does not exist —
+  // this function then no-ops. Live handoffs live in per-session slots
+  // (.kenaz/specialist/handoffs/) and are read via the ansuz_handoff_snapshot MCP
+  // tool (kenaz.rs, TASK_1828) / handoff-resolver; per-session slots are NOT
+  // consumed-and-deleted here (deleting the latest slot would race parallel sessions).
+  const handoffPath = ANSUZ_HANDOFF_PATH;
+
+  if (!fs.existsSync(handoffPath)) {
+    return { loaded: false, summary: null };
+  }
+
+  let handoff;
+  try {
+    handoff = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+  } catch (e) {
+    warnings.push(`HANDOFF: invalid legacy handoff slot (${e.message}) — deleting corrupted legacy file`);
+    try { fs.unlinkSync(handoffPath); } catch (unlinkErr) {
+      warnings.push(`HANDOFF: failed to delete corrupted active slot (${unlinkErr.message})`);
+    }
+    return { loaded: false, summary: null };
+  }
+
+  if (handoff && handoff.cleared === true) {
+    return { loaded: false, summary: null };
+  }
+
+  const summary = {
+    session_id: handoff?.session_id || null,
+    topic: handoff?.isbar?.situation?.current_topic || null,
+    first_action: handoff?.isbar?.recommendation?.first_action || null,
+    pending_decisions: Array.isArray(handoff?.isbar?.situation?.pending_decisions)
+      ? handoff.isbar.situation.pending_decisions
+      : [],
+    unfinished: Array.isArray(handoff?.isbar?.assessment?.unfinished)
+      ? handoff.isbar.assessment.unfinished
+      : [],
+  };
+
+  const taskId = handoff?.session_id || `ansuz-handoff-${Date.now()}`;
+  const scope = `session-handoff:${taskId}`;
+  const serialized = JSON.stringify(handoff, null, 2);
+
+  // TASK_1983 (R4): explicit project on every Hippocampus call — omitted projectPath
+  // silently follows the Dashboard's currently-selected project (feedback_mcp_default_project_drift).
+  const handoffProjectPath = resolveHandoffProjectRoot();
+
+  const started = callMcpTool('hippocampus_episode_start', {
+    task_id: taskId,
+    scope,
+    agent_role: 'ansuz',
+    agent_skill: 'session_handoff',
+    projectPath: handoffProjectPath,
+  });
+  const episodeId = started && started.episode_id;
+  if (!episodeId) {
+    warnings.push('HANDOFF: failed to archive to Hippocampus (episode_start unavailable) — retaining file, summary still surfaced');
+    return { loaded: true, summary, retained: true, archive_failed: true };
+  }
+
+  const appended = callMcpTool('hippocampus_episode_append', {
+    episode_id: episodeId,
+    phase: 'handoff',
+    content: serialized,
+    outcome: 'restored',
+    projectPath: handoffProjectPath,
+  });
+  if (!appended || !appended.entry_id) {
+    warnings.push('HANDOFF: failed to archive to Hippocampus (episode_append unavailable) — retaining file, summary still surfaced');
+    return { loaded: true, summary, retained: true, archive_failed: true };
+  }
+
+  const closed = callMcpTool('hippocampus_episode_close', {
+    episode_id: episodeId,
+    summary: `Session handoff from ${taskId}: topic=${summary.topic || 'unknown'}, pending=${summary.pending_decisions.length} decisions`,
+    lesson: summary.first_action || 'Resume the preserved session context before new analysis.',
+    outcome: 'success',
+    projectPath: handoffProjectPath,
+  });
+  if (!closed || closed.status !== 'closed') {
+    warnings.push('HANDOFF: failed to archive to Hippocampus (episode_close unavailable) — retaining file, summary still surfaced');
+    return { loaded: true, summary, retained: true, archive_failed: true };
+  }
+
+  try {
+    fs.unlinkSync(handoffPath);
+  } catch (e) {
+    warnings.push(`HANDOFF: archived to Hippocampus but failed to delete active slot (${e.message})`);
+    return { loaded: true, summary, retained: true };
+  }
+
+  return { loaded: true, summary };
+}
+
+// ═══════════════════════════════════════
+//  Blind Spot Guard Injection (TASK_923)
+//  Re-injects active blind_spot guards at enterPhase for phases >= 3
+//  to prevent context compression from losing Phase 0 self-model awareness.
+// ═══════════════════════════════════════
+
+/**
+ * Parse the guard mapping YAML (simple subset — no external deps).
+ * Returns { guards: { 'B-XXX': { description, phases, conditions: { N: text } } } }
+ */
+function parseBlindSpotGuardsYaml(content) {
+  const guards = {};
+  let currentId = null;
+  let inConditions = false;
+
+  for (const line of content.split('\n')) {
+    // Skip comments and empty lines
+    if (/^\s*#/.test(line) || !line.trim()) continue;
+
+    // Top-level guard ID: "  B-001:"
+    const idMatch = line.match(/^\s{2}(B-\d+):\s*$/);
+    if (idMatch) {
+      currentId = idMatch[1];
+      guards[currentId] = { description: '', phases: [], conditions: {} };
+      inConditions = false;
+      continue;
+    }
+
+    if (!currentId) continue;
+
+    // description: "..."
+    const descMatch = line.match(/^\s+description:\s*"(.+)"\s*$/);
+    if (descMatch) {
+      guards[currentId].description = descMatch[1];
+      inConditions = false;
+      continue;
+    }
+
+    // phases: [3, 8, 9]
+    const phasesMatch = line.match(/^\s+phases:\s*\[([^\]]*)\]/);
+    if (phasesMatch) {
+      guards[currentId].phases = phasesMatch[1].split(',').map(s => parseInt(s.trim(), 10)).filter(n => !isNaN(n));
+      inConditions = false;
+      continue;
+    }
+
+    // conditions:
+    if (/^\s+conditions:\s*$/.test(line)) {
+      inConditions = true;
+      continue;
+    }
+
+    // condition entry:  "      3: "text""
+    if (inConditions) {
+      const condMatch = line.match(/^\s+(\d+):\s*"(.+)"\s*$/);
+      if (condMatch) {
+        guards[currentId].conditions[parseInt(condMatch[1], 10)] = condMatch[2];
+      }
+    }
+  }
+
+  return { guards };
+}
+
+/**
+ * Read active blind spot guards for a given phase and specialist.
+ * Merges self-model blind_spots (active only) with guard mapping YAML.
+ * Returns [] on any failure (graceful degradation).
+ *
+ * @param {number} phase - Current phase number
+ * @param {string} specialistName - Specialist name (e.g. 'Ansuz')
+ * @returns {Array<{ id: string, description: string, guard: string }>}
+ */
+function readBlindSpotGuards(phase, specialistName) {
+  const specialist = specialistName || 'Ansuz';
+
+  // 1. Read merged self-model to get blind_spots with status
+  const growthPath = path.join(BASE_DIR, '.kenaz', 'specialist', `${specialist.toLowerCase()}_self_model.json`);
+  const seedPath = path.join(BASE_DIR, '.specialist', specialist, 'self_model_seed.json');
+
+  let blindSpots = [];
+  try {
+    // Try growth model first (has status field)
+    if (fs.existsSync(growthPath)) {
+      const growth = JSON.parse(fs.readFileSync(growthPath, 'utf8'));
+      blindSpots = growth.blind_spots || [];
+    }
+    // Merge with seed core_blind_spots (always active by definition)
+    if (fs.existsSync(seedPath)) {
+      const seed = JSON.parse(fs.readFileSync(seedPath, 'utf8'));
+      const coreSpots = (seed.core_blind_spots || []).map(s => ({ ...s, status: 'active' }));
+      // Merge: growth entries override seed entries by ID
+      const growthIds = new Set(blindSpots.map(b => b.id));
+      for (const core of coreSpots) {
+        if (!growthIds.has(core.id)) blindSpots.push(core);
+      }
+    }
+  } catch {
+    return []; // graceful degradation
+  }
+
+  // Filter to active only
+  const activeSpots = blindSpots.filter(b => b.status && b.status.startsWith('active'));
+  if (activeSpots.length === 0) return [];
+
+  // 2. Read guard mapping YAML
+  const guardYamlPath = path.join(BASE_DIR, '.specialist', specialist, 'guards', 'blind_spot_guards.yaml');
+  let guardMapping = {};
+  try {
+    if (!fs.existsSync(guardYamlPath)) return [];
+    const yamlContent = fs.readFileSync(guardYamlPath, 'utf8');
+    const parsed = parseBlindSpotGuardsYaml(yamlContent);
+    guardMapping = parsed.guards || {};
+  } catch {
+    return []; // graceful degradation
+  }
+
+  // 3. Map active blind spots to phase-specific guards
+  const guards = [];
+  for (const spot of activeSpots) {
+    const mapping = guardMapping[spot.id];
+    if (!mapping) continue;
+    if (!mapping.phases.includes(phase)) continue;
+    const condition = mapping.conditions[phase];
+    if (!condition) continue;
+
+    guards.push({
+      id: spot.id,
+      description: spot.description,
+      guard: condition,
+    });
+  }
+
+  return guards;
+}
+
+// ═══════════════════════════════════════
+//  Self-Model Seed Protection (TASK_869)
+// ═══════════════════════════════════════
+
+/**
+ * Compute SHA256 of a file's raw content.
+ */
+function computeFileSHA256(filePath) {
+  const content = fs.readFileSync(filePath, 'utf8');
+  return crypto.createHash('sha256').update(content, 'utf8').digest('hex');
+}
+
+/**
+ * Verify self_model_seed.json integrity against stored checksum.
+ * On first run (no .sha256 file), generates checksum + backup.
+ * Returns { ok, expected, actual, first_run?, warning? }
+ */
+function verifySeedIntegrity() {
+  if (!fs.existsSync(SEED_PATH)) {
+    return { ok: false, expected: null, actual: null, warning: 'self_model_seed.json not found' };
+  }
+  if (!fs.existsSync(SEED_CHECKSUM_PATH)) {
+    // First run — generate reference checksum and backup
+    const checksum = computeFileSHA256(SEED_PATH);
+    fs.writeFileSync(SEED_CHECKSUM_PATH, checksum, 'utf8');
+    fs.copyFileSync(SEED_PATH, SEED_BACKUP_PATH);
+    return { ok: true, expected: checksum, actual: checksum, first_run: true };
+  }
+  const expected = fs.readFileSync(SEED_CHECKSUM_PATH, 'utf8').trim();
+  const actual = computeFileSHA256(SEED_PATH);
+  return { ok: expected === actual, expected, actual };
+}
+
+/**
+ * Restore self_model_seed.json from backup and reset checksum.
+ * Returns { restored: boolean, error?: string }
+ */
+function restoreSeedFromBackup() {
+  if (!fs.existsSync(SEED_BACKUP_PATH)) {
+    return { restored: false, error: 'No backup file found at self_model_seed.backup.json' };
+  }
+  try {
+    fs.copyFileSync(SEED_BACKUP_PATH, SEED_PATH);
+    const restoredChecksum = computeFileSHA256(SEED_PATH);
+    fs.writeFileSync(SEED_CHECKSUM_PATH, restoredChecksum, 'utf8');
+    return { restored: true };
+  } catch (e) {
+    return { restored: false, error: e.message };
+  }
+}
+
+/**
+ * Merge seed layer + growth layer into a unified self-model.
+ * Seed fields ALWAYS win (especially narrative).
+ * Growth-only fields (tendencies, blind_spots, growth_edges) come from growth layer.
+ * Returns { model, seed, growth, warnings[] }
+ */
+function mergeSeedAndGrowth() {
+  const warnings = [];
+  let seed = null;
+  try {
+    seed = JSON.parse(fs.readFileSync(SEED_PATH, 'utf8'));
+  } catch (e) {
+    return { model: null, seed: null, growth: null, warnings: [`Seed read error: ${e.message}`] };
+  }
+
+  let growth = null;
+  if (fs.existsSync(GROWTH_PATH)) {
+    try {
+      growth = JSON.parse(fs.readFileSync(GROWTH_PATH, 'utf8'));
+    } catch (e) {
+      warnings.push(`Growth layer read error: ${e.message}`);
+    }
+  }
+
+  // Seed fields always win
+  const model = {
+    version: seed.version,
+    specialist: seed.specialist,
+    narrative: seed.narrative,           // seed wins — immutable soul anchor
+    core_tendencies: seed.core_tendencies || [],
+    core_blind_spots: seed.core_blind_spots || [],
+  };
+
+  // Growth fields layered on top (observable, accumulating evidence)
+  if (growth) {
+    model.tendencies      = growth.tendencies      || [];
+    model.blind_spots     = growth.blind_spots     || [];
+    model.growth_edges    = growth.growth_edges    || [];
+    model.last_updated    = growth.last_updated    || null;
+    model.last_updated_by = growth.last_updated_by || null;
+  }
+
+  return { model, seed, growth, warnings };
+}
+
+/** Growth-only fields allowed for Phase 11 self-model writes (seed-protected fields excluded) */
+const GROWTH_ONLY_FIELDS = ['tendencies', 'blind_spots', 'growth_edges', 'last_updated', 'last_updated_by'];
+
+/**
+ * Write growth-only fields to .kenaz/ansuz_self_model.json.
+ * Strips any seed-protected fields (narrative, core_*) from the update.
+ * Returns { written: boolean, error?: string }
+ */
+function writeSelfModelGrowth(update) {
+  let current = {};
+  if (fs.existsSync(GROWTH_PATH)) {
+    try { current = JSON.parse(fs.readFileSync(GROWTH_PATH, 'utf8')); } catch { /* start fresh */ }
+  }
+  const cleaned = {};
+  for (const field of GROWTH_ONLY_FIELDS) {
+    if (field in update) cleaned[field] = update[field];
+  }
+  const updated = {
+    ...current,
+    ...cleaned,
+    last_updated: cleaned.last_updated || new Date().toISOString(),
+  };
+  // Preserve metadata fields that live in the growth file
+  updated.version    = current.version    || '1.0.0';
+  updated.specialist = current.specialist || 'ansuz';
+  try {
+    const kenazDir = path.dirname(GROWTH_PATH);
+    if (!fs.existsSync(kenazDir)) fs.mkdirSync(kenazDir, { recursive: true });
+    fs.writeFileSync(GROWTH_PATH, JSON.stringify(updated, null, 2), 'utf8');
+    return { written: true };
+  } catch (e) {
+    return { written: false, error: e.message };
+  }
+}
+
+// ═══════════════════════════════════════
+//  Ansuz Inbox — Fatigue Warning Messages (TASK_943)
+// ═══════════════════════════════════════
+
+const ANSUZ_INBOX_PATH = path.join(BASE_DIR, '.kenaz', 'specialist', 'ansuz_inbox.json');
+
+/**
+ * Read unprocessed fatigue_warning messages from ansuz_inbox.json.
+ * Returns array of messages (empty if none or file absent).
+ * Graceful degradation: returns [] on any error.
+ */
+function readAnsuzInboxMessages() {
+  try {
+    if (!fs.existsSync(ANSUZ_INBOX_PATH)) return [];
+    const raw = fs.readFileSync(ANSUZ_INBOX_PATH, 'utf8');
+    const data = JSON.parse(raw);
+    const messages = Array.isArray(data.messages) ? data.messages : [];
+    const processedIds = new Set(Array.isArray(data.processed_ids) ? data.processed_ids : []);
+    return messages.filter(m => m.type === 'fatigue_warning' && !processedIds.has(m.id));
+  } catch {
+    return [];
+  }
+}
+
+// ═══════════════════════════════════════
+//  Enter Logic
+// ═══════════════════════════════════════
+
+function enterPhase(phase, taskId, specialistName = null) {
+  const chart = readChart(taskId);
+  const warnings = [];
+
+  // Prerequisite: previous phase must be completed (phase > 0)
+  if (phase > 0) {
+    const prevKey = String(phase - 1);
+    const prev = chart.phases[prevKey];
+    if (prev && prev.status !== 'completed') {
+      return outputResult({
+        phase,
+        action: 'enter',
+        modules_loaded: [],
+        module_content: {},
+        checklist: [],
+        warnings: [],
+        blocked: true,
+        block_reason: `Phase ${prevKey} is not completed (status: ${prev.status}). Complete the previous phase before entering phase ${phase}.`,
+      });
+    }
+    if (!prev) {
+      warnings.push(`No record for phase ${prevKey} — treating as first entry to phase ${phase}`);
+    }
+  }
+
+  // TASK_1104: Tool reflex enforcement at enter time.
+  // These run BEFORE module/instruction loading so blocked phases abort cheaply.
+  // No emergency override — ritual failures must be fixed by the ritual, not bypassed.
+
+  // Phase 0: consecutive ritual skip escalation. >=3 trailing skips in
+  // ansuz_ritual_log.jsonl force a hard block until the agent acks and the
+  // log is advanced by a non-skip entry.
+  if (phase === 0) {
+    // TASK_1113: warn (non-blocking) when Phase 0 is entered without the
+    // gated session.js prompt having been consumed. We detect this by
+    // inspecting ritual_state.json for a `manifest_read_at` marker — the
+    // gated boot path leaves this unset until the agent explicitly records
+    // having read the manifest. Missing marker → 'manifest_skipped' entry
+    // in ansuz_ritual_log.jsonl.
+    try {
+      const RITUAL_STATE_PATH = path.join(BASE_DIR, '.kenaz', 'specialist', 'ritual_state.json');
+      if (fs.existsSync(RITUAL_STATE_PATH)) {
+        const rs = JSON.parse(fs.readFileSync(RITUAL_STATE_PATH, 'utf8'));
+        if (!rs || !rs.manifest_read_at) {
+          warnings.push('Phase 0 manifest_skipped: ritual_state.json has no manifest_read_at — gated boot manifest appears to have been bypassed. Run `node .specialist/tools/session.js prompt Ansuz --depth=kernel --gated` and read the manifest before phase-gate enter.');
+          appendRitualLog('manifest', 'skipped', { task_id: taskId, phase, reason: 'no manifest_read_at in ritual_state.json' });
+        }
+      } else {
+        warnings.push('Phase 0 manifest_skipped: ritual_state.json missing — gated boot not invoked. Run session.js prompt Ansuz --gated first.');
+        appendRitualLog('manifest', 'skipped', { task_id: taskId, phase, reason: 'ritual_state.json missing' });
+      }
+    } catch (e) {
+      warnings.push(`Phase 0 manifest check error: ${e.message}`);
+    }
+
+    const skips = countConsecutiveRitualSkips();
+    if (skips >= 3) {
+      return outputResult({
+        phase,
+        action: 'enter',
+        modules_loaded: [],
+        module_content: {},
+        checklist: [],
+        warnings: [],
+        blocked: true,
+        block_reason: `Phase 0 HARD-BLOCKED: ${skips} consecutive ritual skips detected in ansuz_ritual_log.jsonl. Agent must acknowledge: ritual failures fix the ritual — no emergency override. Append a non-skip entry (outcome=completed or low_quality with reason) to ${RITUAL_LOG_PATH} before re-entering Phase 0.`,
+      });
+    }
+  }
+
+  // Phase 9: ddx check. If the task description contains uncertainty markers,
+  // ddx_log.jsonl MUST contain a matching entry.
+  if (phase === 9) {
+    const desc = readTaskDescription(taskId);
+    if (desc && /\b(uncertain|unclear|hypothesis|maybe|possibly)\b/i.test(desc)) {
+      if (!ddxLogHas(taskId)) {
+        appendRitualLog('ddx', 'skipped', { task_id: taskId, phase });
+        return outputResult({
+          phase,
+          action: 'enter',
+          modules_loaded: [],
+          module_content: {},
+          checklist: [],
+          warnings: [],
+          blocked: true,
+          block_reason: `Phase 9 BLOCKED: task description contains uncertainty markers (uncertain|unclear|hypothesis|maybe|possibly) but no ddx_log entry for ${taskId}. Enumerate competing hypotheses and append to ${DDX_LOG_PATH} (fields: {task_id, hypotheses:[...], timestamp}) before entering Phase 9.`,
+        });
+      }
+    }
+  }
+
+  // Phase 11: inscribe check. If chart / progress notes contain learning markers,
+  // inscribe_log.jsonl MUST contain a synapse_inscribe record for the task.
+  if (phase === 11) {
+    let chartText = '';
+    try { chartText = JSON.stringify(readChart(taskId)); } catch { /* ignore */ }
+    if (chartText && /\b(learned|insight|surprise|non-obvious)\b/i.test(chartText)) {
+      if (!inscribeLogHas(taskId)) {
+        appendRitualLog('inscribe', 'skipped', { task_id: taskId, phase });
+        return outputResult({
+          phase,
+          action: 'enter',
+          modules_loaded: [],
+          module_content: {},
+          checklist: [],
+          warnings: [],
+          blocked: true,
+          block_reason: `Phase 11 BLOCKED: session contains learning markers (learned|insight|surprise|non-obvious) but no synapse_inscribe record for ${taskId}. Call synapse_inscribe and append an entry to ${INSCRIBE_LOG_PATH} (fields: {task_id, rune_id, timestamp}) before entering Phase 11.`,
+        });
+      }
+    }
+  }
+
+  // Load phase instructions and context hints (TASK_583)
+  const phaseInstructions = loadPhaseInstructions(phase);
+  if (phaseInstructions.warning) {
+    warnings.push(phaseInstructions.warning);
+  }
+  const contextHints = buildContextHints(phase, chart, phaseInstructions, warnings);
+
+  // Load inject rules/specialist files declared in phase YAML (TASK_609)
+  let injectedRules = {};
+  if (phaseInstructions.content) {
+    const injectConfig = extractInjectConfig(phaseInstructions.content);
+    injectedRules = loadInjectedFiles(injectConfig, warnings);
+  }
+
+  // Decide and load modules
+  const moduleNames = decideModules(phase, chart);
+  const moduleContent = {};
+  const loadedModules = [];
+
+  for (const name of moduleNames) {
+    const mod = loadModule(name);
+    moduleContent[name] = mod;
+    if (mod.error) {
+      warnings.push(mod.error);
+    } else {
+      loadedModules.push(name);
+      if (!chart.vitals.modules_ever_loaded.includes(name)) {
+        chart.vitals.modules_ever_loaded.push(name);
+      }
+    }
+    if (mod.warning) {
+      warnings.push(mod.warning);
+    }
+  }
+
+  // Record phase entry
+  const phaseKey = String(phase);
+  const existingPhase = chart.phases[phaseKey];
+  if (existingPhase) {
+    warnings.push(`Re-entering phase ${phase} (previous status: ${existingPhase.status})`);
+    existingPhase.entered_at = new Date().toISOString();
+    existingPhase.status = 'active';
+    existingPhase.modules_loaded = loadedModules;
+    existingPhase.checklist_result = null;
+    // Reset checklist_items to base list so lesson guard conditions are not duplicated
+    // on re-entry (they will be re-appended below when guards are loaded).
+    existingPhase.checklist_items = PHASE_CHECKLISTS[phase] ? [...PHASE_CHECKLISTS[phase]] : [];
+  } else {
+    chart.phases[phaseKey] = {
+      entered_at: new Date().toISOString(),
+      exited_at: null,
+      status: 'active',
+      modules_loaded: loadedModules,
+      checklist_items: PHASE_CHECKLISTS[phase] || [],
+      checklist_result: null,
+      data: {},
+    };
+  }
+
+  // Phase 0: hippocampus recall removed from phase-gate.
+  // Ansuz calls hippocampus_episode_recall directly when episodic context is needed.
+  // This keeps phase-gate Phase 0 output small (injected_rules like agent-workflow.yaml
+  // are 20KB+ and are already part of the assembled Ansuz persona).
+
+  // Phase 0: seed integrity check + merge (TASK_869)
+  let selfModelResult = null;
+  if (phase === 0) {
+    // 1. Verify seed integrity; restore from backup on tamper detection
+    let integrityInfo;
+    try {
+      integrityInfo = verifySeedIntegrity();
+    } catch (e) {
+      integrityInfo = { ok: false, expected: null, actual: null, warning: `Integrity check error: ${e.message}` };
+    }
+
+    if (!integrityInfo.ok) {
+      if (integrityInfo.warning) {
+        warnings.push(`SEED: ${integrityInfo.warning}`);
+      } else {
+        // Checksum mismatch — attempt restore
+        const restore = restoreSeedFromBackup();
+        if (restore.restored) {
+          warnings.push('SECURITY: self_model_seed.json checksum mismatch — restored from backup');
+        } else {
+          warnings.push(
+            `SECURITY: self_model_seed.json tampered (expected: ${(integrityInfo.expected || '').slice(0, 8)}..., ` +
+            `actual: ${(integrityInfo.actual || '').slice(0, 8)}...) — restore failed: ${restore.error}`
+          );
+        }
+      }
+    } else if (integrityInfo.first_run) {
+      warnings.push('SEED: first-run — checksum generated and backup created (self_model_seed.sha256 + .backup.json)');
+    }
+
+    // 2. Merge seed + growth into unified self-model
+    const { model, warnings: mergeWarnings } = mergeSeedAndGrowth();
+    if (mergeWarnings && mergeWarnings.length > 0) warnings.push(...mergeWarnings);
+
+    selfModelResult = {
+      loaded: model !== null,
+      integrity_ok: integrityInfo.ok,
+      model: model || null,
+    };
+
+    // Track self_model_loaded in phase data for exit validation reference
+    const phaseRec = chart.phases[String(phase)];
+    if (phaseRec) phaseRec.data.self_model_loaded = model !== null;
+  }
+
+  // Phase 0: User model language injection (TASK_1041)
+  // Load .kenaz/user_model.json to inject preferred_language; fall back to OS locale.
+  let userModelResult = null;
+  if (phase === 0) {
+    userModelResult = readUserModel(BASE_DIR, warnings);
+    // Track in phase data for downstream reference
+    const phaseRec = chart.phases[String(phase)];
+    if (phaseRec) {
+      phaseRec.data.user_model_loaded = userModelResult.loaded;
+      phaseRec.data.user_model_language = userModelResult.preferred_language;
+      phaseRec.data.user_model_source = userModelResult.source;
+    }
+  }
+
+  // Phase 0: Session handoff auto-restore (Tier 3x)
+  // Reduce Ansuz boot cognitive load by restoring archived context in phase-gate itself.
+  let sessionHandoffResult = null;
+  if (phase === 0) {
+    sessionHandoffResult = restoreSessionHandoff(warnings);
+    const phaseRec = chart.phases[String(phase)];
+    if (phaseRec) {
+      phaseRec.data.session_handoff_loaded = sessionHandoffResult.loaded;
+      if (sessionHandoffResult.summary) {
+        phaseRec.data.session_handoff_summary = sessionHandoffResult.summary;
+      }
+    }
+  }
+
+  // Phase 0: Dynamic user context synthesis (TASK_1218)
+  // Read recent user observations and cross-reference the long-lived user profile.
+  let dynamicUserContext = null;
+  if (phase === 0) {
+    dynamicUserContext = buildDynamicUserContext(warnings);
+    const phaseRec = chart.phases[String(phase)];
+    if (phaseRec) {
+      phaseRec.data.dynamic_user_context = dynamicUserContext;
+    }
+  }
+
+  // Phase 0: Git context auto-enrichment
+  let gitContextResult = null;
+  if (phase === 0) {
+    gitContextResult = readGitContext(process.cwd(), warnings);
+    const phaseRec = chart.phases[String(phase)];
+    if (phaseRec) {
+      phaseRec.data.git_context = gitContextResult;
+      phaseRec.data.git_context_loaded = gitContextResult !== null;
+      phaseRec.data.git_context_since_iso = gitContextResult ? gitContextResult.since_iso : null;
+      phaseRec.data.git_context_since_source = gitContextResult ? gitContextResult.since_source : null;
+    }
+  }
+
+  // Phase 8: compression fallback only (the Muninn dispatch modulation was retired, TASK_2345).
+  if (phase === 8 && taskId) {
+    emitCompressionFallbackIfNeeded(chart, taskId, warnings);
+  }
+
+  // Phases >= 3: Blind Spot Guard Injection (TASK_923)
+  // Re-inject active blind_spot guards that were loaded in Phase 0 self-model
+  // but lost to context compression by later phases.
+  let blindSpotGuards = null;
+  if (phase >= 3) {
+    const guards = readBlindSpotGuards(phase, specialistName);
+    if (guards.length > 0) {
+      blindSpotGuards = guards;
+      // Record in phase data
+      const phaseRec = chart.phases[String(phase)];
+      if (phaseRec) {
+        phaseRec.data.blind_spot_guards_injected = guards.map(g => g.id);
+      }
+    }
+  }
+
+  // Phases >= 1: Lesson Guard Injection (TASK_1071)
+  // Inject durable reflections promoted via the Reflection-to-Control pipeline.
+  // Unlike blind_spot_guards (self-model B-XXX), lesson guards (L-XXX) are promoted
+  // from Synapse runes, Muninn episode lessons, or manual reflection promotion.
+  let lessonGuards = null;
+  if (phase >= 1) {
+    try {
+      const lessonGuardModule = require(path.join(BASE_DIR, '.specialist', 'tools', 'lesson-guard.js'));
+      const lgList = lessonGuardModule.readLessonGuardsForPhase(phase);
+      if (lgList.length > 0) {
+        // TASK_1164: Run precompute for guards with precompute field BEFORE building checklist
+        // so rendered output can embed inline below the [LG:L-XXX] line.
+        // runPrecompute mutates each guard object with a precompute_result field.
+        // Wrapped in try/catch so an unexpected error never blocks lesson_guards loading.
+        try {
+          const { runPrecompute } = require(path.join(BASE_DIR, '.specialist', 'tools', 'precompute-runner.js'));
+          const phaseRecForData = chart.phases[String(phase)];
+          const taskData = (phaseRecForData && phaseRecForData.data) ? phaseRecForData.data : {};
+          runPrecompute(lgList, taskData, BASE_DIR);
+        } catch (pcErr) {
+          warnings.push(`precompute: ${pcErr.message}`);
+        }
+
+        lessonGuards = lgList;
+        // Record injected guard IDs in phase data for audit trail
+        // Phase behavior change: append guard conditions to checklist_items so
+        // the specialist sees them as explicit obligations at phase entry (TASK_1076).
+        const phaseRec = chart.phases[String(phase)];
+        if (phaseRec) {
+          phaseRec.data.lesson_guards_injected = lgList.map(g => g.id);
+          // TASK_1163: Snapshot full guard state per-injection so post-complete
+          // detector reads the signature that was active AT injection time, not the
+          // current yaml state (which may have been mutated by auto-expire etc).
+          phaseRec.data.lesson_guards_snapshot = lgList.map(g => ({
+            id: g.id,
+            failure_signature: g.failure_signature || null,
+            injection_ts: new Date().toISOString(),
+            phase,
+          }));
+          // TASK_1163: Increment injection_count for each guard (used by hit_rate calc)
+          try {
+            const lgMod = require(path.join(BASE_DIR, '.specialist', 'tools', 'lesson-guard.js'));
+            if (typeof lgMod.incrementInjectionCount === 'function') {
+              for (const g of lgList) lgMod.incrementInjectionCount(g.id);
+            }
+          } catch { /* never block injection on tracking failure */ }
+          for (const lg of lgList) {
+            phaseRec.checklist_items.push(`[LG:${lg.id}] ${lg.guard}`);
+            // TASK_1164: Embed precompute result as ↳ line below the guard text.
+            // Fall back to text-only injection if precompute returned nothing.
+            if (lg.precompute && lg.precompute_result != null) {
+              phaseRec.checklist_items.push(`↳ ${lg.precompute_result}`);
+            }
+          }
+        }
+      }
+    } catch { /* graceful degradation — lesson-guard.js unavailable */ }
+  }
+
+  if (warnings.length > 0) {
+    chart.vitals.warnings.push(...warnings);
+  }
+
+  writeChart(chart);
+
+  return outputResult({
+    phase,
+    action: 'enter',
+    modules_loaded: loadedModules,
+    module_content: moduleContent,
+    checklist: (chart.phases[String(phase)] || {}).checklist_items || PHASE_CHECKLISTS[phase] || [],
+    // Phase 0 skips instructions + injected_rules: the assembled persona already contains them.
+    // Other phases still receive full instructions + rules.
+    instructions: phase === 0 ? null : phaseInstructions.content,
+    context_hints: Object.keys(contextHints).length > 0 ? contextHints : null,
+    injected_rules: phase === 0 ? {} : injectedRules,
+    poem_stanza: phase === 0 ? (phaseInstructions.poem || null) : undefined,
+    poem_cli_format: phase === 0 ? (extractBlockScalar(phaseInstructions.content || '', 'cli_format') || null) : undefined,
+    self_model: selfModelResult,   // Phase 0 only; null for all other phases
+    user_model: userModelResult,   // Phase 0 only; null for all other phases (TASK_1041)
+    dynamic_user_context: phase === 0 ? dynamicUserContext : null,
+    git_context: phase === 0 ? gitContextResult : null,
+    session_handoff: phase === 0 ? sessionHandoffResult : null,
+    blind_spot_guards: blindSpotGuards, // Phases >= 3; null for phases 0-2 (TASK_923)
+    lesson_guards: lessonGuards,   // Phases >= 1; null when no active guards (TASK_1071)
+    inbox_messages: (() => { const m = readAnsuzInboxMessages(); return m.length > 0 ? m : null; })(), // TASK_943: fatigue_warning delivery
+    // TASK_1170: exit_template — Phase 0 only. Tells Ansuz exactly what shape the
+    // exit call must have, so the 43% stdout_markers skip rate is preventable at
+    // enter time instead of discovered at exit time after a ~2-minute retry cycle.
+    exit_template: phase === 0 ? {
+      exit_command: 'node .specialist/tools/phase-gate.js exit --phase=0 --data=<json>',
+      exit_required_fields: {
+        poem_displayed: true,
+        ash_loaded: true,
+        session_handoff_loaded: true,
+        consent_uttered: true,
+        // Dynamic read — must equal ANSUZ_CONSENT_STRING exactly; never hard-code a copy
+        consent_string: ANSUZ_CONSENT_STRING,
+        mirror_acknowledged: { id: 'B-XXX', understanding: '<sentence >=30 chars literally containing B-XXX>' },
+        inheritance_grounded: true,
+        // Dynamic read — must equal REQUIRED_STDOUT_MARKERS; never hard-code a copy
+        stdout_markers_emitted: REQUIRED_STDOUT_MARKERS,
+      },
+      exit_verification_notes: [
+        'stdout_markers must appear as user-visible plain text literals in the last 200 lines of conversation jsonl — NOT inside thinking blocks or markdown code fences.',
+        'mirror_acknowledged.understanding must contain the literal string from mirror_acknowledged.id (e.g. "B-XXX").',
+        'consent_string must be byte-for-byte equal to the ANSUZ_CONSENT_STRING constant — no paraphrase, no partial, no extra characters.',
+      ],
+    } : null,
+    warnings,
+    blocked: false,
+    block_reason: null,
+  });
+}
+
+// ═══════════════════════════════════════
+//  Prediction Recording (TASK_914)
+//  Write expected outcomes at Phase 3 exit for outcome tracking in post-complete.
+// ═══════════════════════════════════════
+
+/**
+ * Map an overall_risk or risk string to a confidence value.
+ * Higher risk → lower confidence.
+ */
+function riskToConfidence(risk) {
+  if (!risk) return 0.7;
+  const r = String(risk).toLowerCase();
+  if (r === 'high' || r === 'critical') return 0.4;
+  if (r === 'medium') return 0.7;
+  if (r === 'low' || r === 'none') return 0.9;
+  return 0.7;
+}
+
+/**
+ * Map risk level to predicted health delta.
+ */
+function riskToHealthDelta(risk) {
+  if (!risk) return 'neutral';
+  const r = String(risk).toLowerCase();
+  if (r === 'high' || r === 'critical') return 'negative';
+  if (r === 'low' || r === 'none') return 'positive';
+  return 'neutral';
+}
+
+/**
+ * Write prediction objects to ansuz_predictions.json.
+ * Atomic write via tmp file + rename.
+ * @param {Array} tasks - Array of task objects with { task_id, scope_paths, known_risks, confidence, source }
+ * @param {Array} warnings - Mutable warnings array to push messages into
+ */
+function writePredictions(tasks, warnings) {
+  if (!tasks || !Array.isArray(tasks) || tasks.length === 0) {
+    warnings.push('Phase 3 prediction: no tasks provided — skipping prediction recording');
+    return;
+  }
+
+  const dir = path.dirname(PREDICTIONS_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  // Read existing predictions (atomic read-modify-write)
+  let existing = { predictions: [] };
+  try {
+    if (fs.existsSync(PREDICTIONS_PATH)) {
+      const raw = fs.readFileSync(PREDICTIONS_PATH, 'utf8');
+      const parsed = JSON.parse(raw);
+      if (parsed && Array.isArray(parsed.predictions)) {
+        existing = parsed;
+      }
+    }
+  } catch (e) {
+    warnings.push(`Phase 3 prediction: failed to read existing predictions — starting fresh: ${e.message}`);
+  }
+
+  const now = new Date().toISOString();
+
+  for (const task of tasks) {
+    const taskId = task.task_id || task.id;
+    if (!taskId) continue;
+
+    // Normalize scope_paths to forward slashes
+    const expectedFiles = (task.scope_paths || []).map(p => String(p).replace(/\\/g, '/'));
+
+    // Determine risk from task-level known_risks or overall risk
+    const risk = task.risk || task.risk_level || 'medium';
+    const confidence = typeof task.confidence === 'number'
+      ? task.confidence
+      : riskToConfidence(risk);
+    const predictedHealthDelta = Object.prototype.hasOwnProperty.call(task, 'predicted_health_delta')
+      ? task.predicted_health_delta
+      : riskToHealthDelta(risk);
+    const source = task.source || 'phase_3';
+
+    const prediction = {
+      task_id: taskId,
+      timestamp: now,
+      expected_files: expectedFiles,
+      risk: String(risk).toLowerCase(),
+      confidence: Math.round(confidence * 100) / 100,
+      predicted_health_delta: predictedHealthDelta,
+      source,
+    };
+
+    // Remove existing prediction for same task_id (update semantics)
+    existing.predictions = existing.predictions.filter(p => p.task_id !== taskId);
+    existing.predictions.push(prediction);
+  }
+
+  // Atomic write: tmp file + rename
+  const tmpPath = PREDICTIONS_PATH + '.tmp.' + process.pid;
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify(existing, null, 2), 'utf8');
+    fs.renameSync(tmpPath, PREDICTIONS_PATH);
+  } catch (e) {
+    warnings.push(`Phase 3 prediction: atomic write failed: ${e.message}`);
+    // Cleanup tmp if rename failed
+    try { fs.unlinkSync(tmpPath); } catch { /* ignore */ }
+  }
+}
+
+// ═══════════════════════════════════════
+//  Exit Logic
+// ═══════════════════════════════════════
+
+function exitPhase(phase, taskId, data, specialistName = null, thinkingTags = null) {
+  const chart = readChart(taskId);
+  const phaseKey = String(phase);
+  const warnings = [];
+
+  // Ensure phase record exists (in case enter was skipped)
+  if (!chart.phases[phaseKey]) {
+    chart.phases[phaseKey] = {
+      entered_at: null,
+      exited_at: null,
+      status: 'active',
+      modules_loaded: [],
+      checklist_items: PHASE_CHECKLISTS[phase] || [],
+      checklist_result: null,
+      data: {},
+    };
+    warnings.push(`Phase ${phase} had no entry record — retroactively created`);
+  }
+
+  const phaseRecord = chart.phases[phaseKey];
+  const mergedData = { ...(phaseRecord.data || {}), ...(data || {}) };
+  const rules = PHASE_EXIT_RULES[phase];
+
+  // TASK_1017: Write thinking tags to thinking_log.jsonl (runs before block check
+  // so self-annotation data is never lost even if phase exit is blocked)
+  if (Array.isArray(thinkingTags) && thinkingTags.length > 0) {
+    // Max 3 tags per phase (aligns with TASK_1018 top-3 cap)
+    let tagsToProcess = thinkingTags;
+    if (thinkingTags.length > 3) {
+      const truncMsg = `thinking_tag: ${thinkingTags.length} tags exceeds max 3 — truncating to first 3`;
+      console.error(truncMsg);
+      warnings.push(truncMsg);
+      tagsToProcess = thinkingTags.slice(0, 3);
+    }
+
+    // Validate tags against runtime-loaded principles from kernel.yaml.
+    // If kernel.yaml absent/unreadable, skip validation (accept any tag, no warning).
+    const knownTags = getKnownThinkingTags();
+    const validTags = [];
+    for (const tag of tagsToProcess) {
+      if (knownTags === null || knownTags.has(tag)) {
+        validTags.push(tag);
+      } else {
+        const warnMsg = `thinking_tag: unknown tag "${tag}" — not in kernel.yaml principles, accepted for forward compat`;
+        console.error(warnMsg);
+        warnings.push(warnMsg);
+        validTags.push(tag);
+      }
+    }
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      task_id: taskId,
+      phase,
+      specialist: specialistName || null,
+      tags: validTags,
+    };
+
+    try {
+      const logDir = path.dirname(THINKING_LOG_PATH);
+      if (!fs.existsSync(logDir)) fs.mkdirSync(logDir, { recursive: true });
+      fs.appendFileSync(THINKING_LOG_PATH, JSON.stringify(logEntry) + '\n', 'utf8');
+      mergedData.thinking_tags_written = validTags.length;
+    } catch (e) {
+      warnings.push(`thinking_tag: failed to write thinking_log.jsonl: ${e.message}`);
+      mergedData.thinking_tags_written = 0;
+    }
+  }
+
+  // Validate required fields
+  if (rules && rules.required && rules.required.length > 0) {
+    const missing = rules.required.filter((field) => {
+      const validator = FIELD_VALIDATORS[field];
+      return validator ? !validator(mergedData) : !(field in mergedData);
+    });
+
+    // TASK_1104: Phase 0 ritual stage logging (every exit attempt, pass or fail)
+    if (phase === 0) {
+      const ritualStages = [
+        { stage: 'consent',     field: 'consent_string' },
+        { stage: 'mirror',      field: 'mirror_acknowledged' },
+        { stage: 'inheritance', field: 'inheritance_grounded' },
+      ];
+      for (const { stage, field } of ritualStages) {
+        const validator = FIELD_VALIDATORS[field];
+        const ok = validator ? validator(mergedData) : (field in mergedData);
+        appendRitualLog(stage, ok ? 'completed' : 'skipped', { task_id: taskId, phase, field });
+      }
+
+      // TASK_1190: canary stage writer — 4th ritual marker, not covered by the
+      // field-validator loop above (which handles consent/mirror/inheritance only).
+      // Fires when stdout_markers_emitted self-report contains CANARY_OK literal.
+      if (Array.isArray(mergedData.stdout_markers_emitted) &&
+          mergedData.stdout_markers_emitted.includes('RITUAL::THRESHOLD::CANARY_OK')) {
+        appendRitualLog('canary', 'completed', { task_id: taskId, phase });
+      } else {
+        appendRitualLog('canary', 'skipped', { task_id: taskId, phase, reason: 'CANARY_OK not in stdout_markers_emitted' });
+      }
+
+      // TASK_1113: transcript verification — cross-check self-reported
+      // stdout_markers_emitted against the live conversation jsonl. If the
+      // grep can locate the transcript AND any required marker is absent,
+      // block the exit. If no transcript can be found, record a warning
+      // but do not hard-block (avoid CI false positives).
+      // TASK_1190: when primary path fails (markers missing OR transcript not
+      // found), try ritual_log fallback before blocking.
+      if (Array.isArray(mergedData.stdout_markers_emitted) && mergedData.stdout_markers_emitted.length > 0) {
+        // TASK_1170: use shared const instead of inline array
+        const tx = verifyStdoutMarkersInTranscript(REQUIRED_STDOUT_MARKERS, 200);
+        if (tx.checked && tx.missing.length === 0) {
+          // Primary path succeeded — no change to existing behavior
+          appendRitualLog('stdout_markers', 'completed', { task_id: taskId, phase, transcript: tx.transcript });
+        } else {
+          // Primary path did not fully succeed: either transcript not found (!tx.checked)
+          // or markers missing (tx.checked && tx.missing.length > 0).
+          // TASK_1190: attempt ritual_log fallback before deciding to block.
+          const fb = verifyStdoutMarkersViaRitualLog(REQUIRED_STDOUT_MARKERS);
+          if (fb.accepted) {
+            // Fallback accepted — surface warning but allow exit
+            const missedList = tx.checked ? tx.missing.join(', ') : `(transcript not found: ${tx.note || 'unknown'})`;
+            warnings.push(`Phase 0 exit accepted via ritual_log fallback: transcript grep missed [${missedList}], ritual_log confirmed [${fb.confirmed.join(', ')}]`);
+            appendRitualLog('stdout_markers', 'completed', { task_id: taskId, phase, path: 'ritual_log_fallback', transcript: tx.transcript });
+          } else if (tx.checked && tx.missing.length > 0) {
+            // Both paths checked: transcript found but markers absent, ritual_log also insufficient
+            phaseRecord.status = 'blocked';
+            phaseRecord.checklist_result = 'blocked';
+            appendRitualLog('stdout_markers', 'skipped', { task_id: taskId, phase, missing: tx.missing, transcript: tx.transcript, fallback_note: fb.note || `ritual_log missing: [${fb.missing.join(', ')}]` });
+            if (warnings.length > 0) chart.vitals.warnings.push(...warnings);
+            writeChart(chart);
+            // TASK_1170: actionable hint — bilingual, includes per-marker counts
+            const hintZh = 'markers 必須以 user-visible plain text literal 形式出現在最近 200 行 conversation jsonl；' +
+              '若 count=0 但你確定有輸出，可能原因：(a) 被 thinking block 包住，(b) 被 markdown code fence 包住，' +
+              '(c) banner 或後續輸出太長把 markers 擠出 lookback 窗口 — 請在最後一段 user-visible 文字裡以純文字列出 4 條 marker 再呼叫 exit';
+            const hintEn = 'Markers must appear as user-visible plain text literals in the last 200 lines of conversation jsonl. ' +
+              'If count=0 but you are certain you emitted them, likely causes: ' +
+              '(a) wrapped in a thinking block, (b) wrapped in a markdown code fence, ' +
+              '(c) banner or subsequent output pushed markers out of the 200-line lookback window — ' +
+              'emit all 4 markers as bare plain text in your final user-visible paragraph, then call exit again.';
+            return outputResult({
+              phase,
+              action: 'exit',
+              modules_loaded: phaseRecord.modules_loaded,
+              module_content: {},
+              checklist: phaseRecord.checklist_items,
+              warnings,
+              blocked: true,
+              transcript_marker_counts: tx.counts,
+              hint: hintZh + ' | ' + hintEn,
+              block_reason: `Phase 0 exit BLOCKED: transcript grep of ${tx.transcript} did not find: [${tx.missing.join(', ')}]; ritual_log fallback also failed (missing stages: [${fb.missing.join(', ')}]${fb.note ? ', ' + fb.note : ''}). Emit the literal RITUAL::* markers to stdout during the ritual, then retry exit.`,
+            });
+          } else {
+            // Transcript not found (!tx.checked) AND ritual_log fallback also failed
+            if (fb.note === 'ritual_log missing') {
+              // Both paths are absent — block (edge case a)
+              phaseRecord.status = 'blocked';
+              phaseRecord.checklist_result = 'blocked';
+              appendRitualLog('stdout_markers', 'skipped', { task_id: taskId, phase, transcript_note: tx.note, fallback_note: fb.note });
+              if (warnings.length > 0) chart.vitals.warnings.push(...warnings);
+              writeChart(chart);
+              return outputResult({
+                phase,
+                action: 'exit',
+                modules_loaded: phaseRecord.modules_loaded,
+                module_content: {},
+                checklist: phaseRecord.checklist_items,
+                warnings,
+                blocked: true,
+                block_reason: `Phase 0 exit BLOCKED: transcript not found (${tx.note || 'unknown'}) and ritual_log fallback also failed (${fb.note}). Both verification paths unavailable.`,
+              });
+            } else {
+              // Transcript not found but ritual_log exists with insufficient entries
+              phaseRecord.status = 'blocked';
+              phaseRecord.checklist_result = 'blocked';
+              appendRitualLog('stdout_markers', 'skipped', { task_id: taskId, phase, transcript_note: tx.note, fallback_missing: fb.missing });
+              if (warnings.length > 0) chart.vitals.warnings.push(...warnings);
+              writeChart(chart);
+              return outputResult({
+                phase,
+                action: 'exit',
+                modules_loaded: phaseRecord.modules_loaded,
+                module_content: {},
+                checklist: phaseRecord.checklist_items,
+                warnings,
+                blocked: true,
+                block_reason: `Phase 0 exit BLOCKED: transcript not found (${tx.note || 'unknown'}); ritual_log fallback also insufficient (missing stages: [${fb.missing.join(', ')}]). Both verification paths failed.`,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    if (missing.length > 0) {
+      phaseRecord.status = 'blocked';
+      phaseRecord.checklist_result = 'blocked';
+      if (warnings.length > 0) chart.vitals.warnings.push(...warnings);
+      writeChart(chart);
+      return outputResult({
+        phase,
+        action: 'exit',
+        modules_loaded: phaseRecord.modules_loaded,
+        module_content: {},
+        checklist: phaseRecord.checklist_items,
+        warnings,
+        blocked: true,
+        block_reason: `Phase ${phase} exit BLOCKED: missing required fields [${missing.join(', ')}]. ${rules.description}`,
+      });
+    }
+  }
+
+  // Phase 1 special handling: persist to chart-level fields
+  if (phase === 1) {
+    if (mergedData.chief_complaint) {
+      chart.chief_complaint = mergedData.chief_complaint;
+    }
+    if (mergedData.recall_results) {
+      chart.history.recall_results = Array.isArray(mergedData.recall_results)
+        ? mergedData.recall_results
+        : [mergedData.recall_results];
+    }
+    if (mergedData.research_notes) {
+      chart.history.research_notes = mergedData.research_notes;
+    }
+  }
+
+  // Phase 3 special handling: record predictions for designed tasks (TASK_914)
+  if (phase === 3) {
+    const tasks = mergedData.tasks || mergedData.designed_tasks || mergedData.task_list || [];
+    if (Array.isArray(tasks) && tasks.length > 0) {
+      writePredictions(tasks, warnings);
+      mergedData.predictions_recorded = tasks.length;
+    } else {
+      warnings.push('Phase 3 prediction: no tasks array found in exit data (expected data.tasks) — predictions not recorded');
+      mergedData.predictions_recorded = 0;
+    }
+  }
+
+  // Phase 3: capture design inputs for post-complete attribution (TASK_1081)
+  if (phase === 3 && taskId) {
+    try {
+      const dr = require(path.join(BASE_DIR, '.specialist', 'tools', 'design-reasoning.js'));
+      const tasks3 = mergedData.tasks || mergedData.designed_tasks || mergedData.task_list || [];
+
+      const explicitPrinciples = Array.isArray(mergedData.principles_applied) ? mergedData.principles_applied : [];
+      const mergedPrinciples = Array.isArray(thinkingTags) && thinkingTags.length > 0
+        ? Array.from(new Set([...explicitPrinciples, ...thinkingTags]))
+        : explicitPrinciples;
+
+      const designEntry = dr.recordDesignReasoning({
+        taskId,
+        principlesApplied: mergedPrinciples,
+        guardsApplied: Array.isArray(mergedData.guards_applied) ? mergedData.guards_applied : [],
+        formationSelected: mergedData.formation_selected || mergedData.formation || null,
+        subtaskCount: Array.isArray(tasks3) && tasks3.length > 0 ? tasks3.length : (mergedData.subtask_count || null),
+        splitRationale: mergedData.split_rationale || null,
+        dependencyAssumptions: Array.isArray(mergedData.dependency_assumptions) ? mergedData.dependency_assumptions : [],
+        riskAssessment: mergedData.risk_assessment || null,
+        notes: mergedData.design_notes || mergedData.notes || null,
+      });
+
+      mergedData.design_inputs_recorded = true;
+      mergedData.design_inputs_timestamp = designEntry.timestamp;
+    } catch (e) {
+      warnings.push(`Phase 3 design capture: failed to record design inputs: ${e.message}`);
+      mergedData.design_inputs_recorded = false;
+    }
+  }
+
+  // Phase 9 special handling: increment fix_count for fix tasks
+  if (phase === 9 && rules && rules.trackFix) {
+    if (mergedData.is_fix_task === true || mergedData.fix_task === true) {
+      chart.vitals.fix_count += 1;
+    }
+  }
+
+  // Phase 9: validate progress notes (TASK_579)
+  if (phase === 9) {
+    const { validation, warnings: noteWarnings } = validateProgressNotes(chart, taskId);
+    mergedData.progress_note_validation = validation;
+    if (noteWarnings.length > 0) warnings.push(...noteWarnings);
+  }
+
+  // Phase 11: validate Ansuz identity before allowing self-model writes (TASK_869)
+  if (phase === 11) {
+    const hasSelfModelUpdate = mergedData.self_model_update !== undefined && mergedData.self_model_update !== null;
+    if (hasSelfModelUpdate) {
+      if (specialistName !== 'ansuz') {
+        // Reject: non-Ansuz session attempting self-model write
+        phaseRecord.status = 'blocked';
+        phaseRecord.checklist_result = 'blocked';
+        if (warnings.length > 0) chart.vitals.warnings.push(...warnings);
+        writeChart(chart);
+        return outputResult({
+          phase,
+          action: 'exit',
+          modules_loaded: phaseRecord.modules_loaded,
+          module_content: {},
+          checklist: phaseRecord.checklist_items,
+          warnings,
+          blocked: true,
+          block_reason: `Phase 11 self-model write BLOCKED: caller must be Ansuz specialist (got: ${specialistName || 'none'}). Pass --specialist=ansuz to exit Phase 11 with self-model updates.`,
+        });
+      }
+      // Ansuz confirmed — write growth-only fields to .kenaz/ansuz_self_model.json
+      const writeResult = writeSelfModelGrowth(mergedData.self_model_update);
+      if (writeResult.written) {
+        mergedData.self_model_written = true;
+      } else {
+        warnings.push(`Phase 11: self-model growth write failed: ${writeResult.error}`);
+        mergedData.self_model_written = false;
+      }
+    }
+  }
+
+  // Phase 11: write session report with emptiness practice + cognitive clarity score (TASK_1207)
+  if (phase === 11) {
+    try {
+      const report = {};
+      // Read existing report if present (Phase 11 may be re-entered)
+      if (fs.existsSync(SESSION_REPORT_PATH)) {
+        try { Object.assign(report, JSON.parse(fs.readFileSync(SESSION_REPORT_PATH, 'utf8'))); } catch { /* start fresh */ }
+      }
+
+      // Emptiness practice: released items from exit data
+      if (Array.isArray(mergedData.emptiness_released_items)) {
+        report.emptiness_released_items = mergedData.emptiness_released_items;
+      }
+
+      // Cognitive clarity score from exit data
+      if (typeof mergedData.cognitive_clarity_score === 'number'
+          && mergedData.cognitive_clarity_score >= 0
+          && mergedData.cognitive_clarity_score <= 1) {
+        report.cognitive_clarity_score = mergedData.cognitive_clarity_score;
+      }
+
+      // Write report if either field is present
+      if (report.emptiness_released_items || report.cognitive_clarity_score !== undefined) {
+        report.schema_version = report.schema_version || '1.0.0';
+        report.session_id = taskId || report.session_id || null;
+        report.timestamp = new Date().toISOString();
+        const reportDir = path.dirname(SESSION_REPORT_PATH);
+        if (!fs.existsSync(reportDir)) fs.mkdirSync(reportDir, { recursive: true });
+        fs.writeFileSync(SESSION_REPORT_PATH, JSON.stringify(report, null, 2), 'utf8');
+        mergedData.session_report_written = true;
+      }
+
+      // Also write to THIS session's handoff slot if it exists (augment, not replace).
+      // TASK_1829: per-session slot via readOwnHandoff — augmenting the "latest"
+      // slot could write into another session's handoff; the legacy singular slot
+      // is retired and never existed on this path anymore (fields were silently lost).
+      try {
+        const own = readOwnSessionHandoff();
+        if (own.handoff && own.sessionId) {
+          const handoff = own.handoff;
+          if (Array.isArray(mergedData.emptiness_released_items)) {
+            handoff.emptiness_released_items = mergedData.emptiness_released_items;
+          }
+          if (typeof mergedData.cognitive_clarity_score === 'number') {
+            handoff.cognitive_clarity_score = mergedData.cognitive_clarity_score;
+          }
+          handoffResolver.writeHandoff(resolveHandoffProjectRoot(), own.sessionId, handoff);
+        }
+      } catch { /* graceful degradation — handoff augment is best-effort */ }
+    } catch (e) {
+      warnings.push(`Phase 11 session report write failed: ${e.message}`);
+      mergedData.session_report_written = false;
+    }
+  }
+
+  // Phase 0: auto-increment sessions_observed for all active/proposed rules (TASK_959)
+  if (phase === 0) {
+    if (!mergedData.dynamic_user_context) {
+      mergedData.dynamic_user_context = buildDynamicUserContext(warnings);
+    }
+    try {
+      const ruleEngine = require(path.join(__dirname, 'rule-engine.js'));
+      const trackResult = ruleEngine.autoTrackSession();
+      mergedData.rules_auto_tracked = true;
+      mergedData.rules_tracked_count = trackResult.total;
+    } catch (e) {
+      warnings.push(`Phase 0 rule auto-tracking failed: ${e.message}`);
+      mergedData.rules_auto_tracked = false;
+    }
+  }
+
+  // Lesson guard acted-on recording (TASK_1076)
+  // Specialist reports which guard IDs demonstrably influenced a decision via
+  // lesson_guards_acted_on: ["L-001", ...] in phase exit data. Phase-gate records
+  // it automatically so specialists don't need to call lesson-guard.js directly.
+  const actedOnIds = mergedData.lesson_guards_acted_on;
+  if (Array.isArray(actedOnIds) && actedOnIds.length > 0) {
+    try {
+      const lessonGuardModule = require(path.join(BASE_DIR, '.specialist', 'tools', 'lesson-guard.js'));
+      const sessionId = String(taskId || `phase-${phase}-${new Date().toISOString()}`);
+      let actedOnRecorded = 0;
+      for (const guardId of actedOnIds) {
+        if (typeof guardId === 'string' && /^L-\d+$/.test(guardId)) {
+          const result = lessonGuardModule.recordActedOn(guardId, sessionId);
+          if (result && result.ok) actedOnRecorded += 1;
+        }
+      }
+      mergedData.lesson_guards_acted_on_recorded = actedOnRecorded;
+    } catch { /* graceful degradation — lesson-guard.js unavailable */ }
+  }
+
+  // Unified memory-to-action acted-on recording (TASK_1072)
+  // Generalised version of lesson_guards_acted_on. Specialist reports via
+  //   memory_acted_on: [
+  //     { source, source_id, action_type, reason, rune_type?, confidence? },
+  //     ...
+  //   ]
+  // covering all six memory sources (handoff/episode/rune/sigil/self_model/
+  // lesson_guard). Delegates to memory-action-log.js which writes the unified
+  // jsonl log and bridges lesson_guard entries back into lesson-guard.js.
+  const memoryActedOn = mergedData.memory_acted_on;
+  if (Array.isArray(memoryActedOn) && memoryActedOn.length > 0) {
+    try {
+      const memLog = require(path.join(BASE_DIR, '.specialist', 'tools', 'memory-action-log.js'));
+      const result = memLog.recordActedOnBatch(memoryActedOn, String(taskId || `phase-${phase}`), phase);
+      mergedData.memory_acted_on_recorded = result.recorded;
+      if (result.failed && result.failed.length > 0) {
+        mergedData.memory_acted_on_failed = result.failed.map((f) => ({
+          source_id: f.item && f.item.source_id,
+          error:     f.error,
+        }));
+        for (const f of result.failed) {
+          warnings.push(`memory_acted_on: ${f.error} (source_id=${f.item && f.item.source_id})`);
+        }
+      }
+    } catch (e) {
+      // Graceful degradation — memory-action-log.js unavailable should never
+      // block a phase exit. Still surface the reason as a warning.
+      warnings.push(`memory_acted_on: module unavailable (${e.message})`);
+    }
+  }
+
+  // L4: Handoff staleness nudge at milestone-phase exits (TASK_1396)
+  // Phases 1, 3, 9, 11 are milestone checkpoints — handoff must stay live.
+  // Soft warning only on first iteration.
+  // If this soft warning fails to change behavior, the next iteration should
+  // hard-block phase exit until handoff is fresh (generated_at within 5 min + last_milestone set).
+  if ([1, 3, 9, 11].includes(phase)) {
+    try {
+      const HANDOFF_STALE_MS = 5 * 60 * 1000;
+      let handoffWarn = null;
+      // TASK_1829: check THIS session's per-session slot (readOwnHandoff), not the
+      // retired singular file (always-missing → permanent false alarm) and not the
+      // latest slot (another session's fresh handoff would false-pass — TASK_1825 class).
+      const own = readOwnSessionHandoff();
+      if (!own.handoff) {
+        handoffWarn = 'missing';
+      } else {
+        const hd = own.handoff;
+        if (!hd.cleared) {
+          const genAt = hd.generated_at ? new Date(hd.generated_at).getTime() : null;
+          const lastMilestone = (hd.isbar && hd.isbar.last_milestone) || hd.last_milestone || null;
+          if (!genAt || (Date.now() - genAt) > HANDOFF_STALE_MS) {
+            handoffWarn = 'stale_timestamp';
+          } else if (!lastMilestone) {
+            handoffWarn = 'empty_last_milestone';
+          }
+        }
+      }
+      if (handoffWarn) {
+        warnings.push(`phase-${phase}-exit: handoff stale or missing — write live_phase_exit update before next milestone`);
+      }
+    } catch { /* L4 check must never block phase exit */ }
+  }
+
+  // Mark phase complete
+  phaseRecord.exited_at = new Date().toISOString();
+  phaseRecord.status = 'completed';
+  phaseRecord.checklist_result = 'pass';
+  phaseRecord.data = mergedData;
+
+  if (warnings.length > 0) {
+    chart.vitals.warnings.push(...warnings);
+  }
+
+  writeChart(chart);
+
+  // Phase 11: write cleared sentinel so downstream readers skip restore (TASK_1390).
+  // TASK_1829: the sentinel goes into THIS session's per-session slot (the legacy
+  // singular slot is retired). Existing slot fields (incl. the Phase 11 augment
+  // above) are preserved under the sentinel instead of clobbered — readers gate on
+  // cleared===true either way. generated_at is re-stamped so the freshness guard in
+  // ansuz-handoff-snapshot.js does not overwrite a just-cleared slot.
+  if (phase === 11) {
+    try {
+      const own = readOwnSessionHandoff();
+      if (own.sessionId) {
+        const cleared = Object.assign({}, own.handoff || {}, {
+          cleared: true,
+          session_id: own.sessionId,
+          ended_at: new Date().toISOString(),
+          generated_at: new Date().toISOString(),
+        });
+        handoffResolver.writeHandoff(resolveHandoffProjectRoot(), own.sessionId, cleared);
+      }
+      // No resolvable session identity → no slot can be attributed to this session;
+      // nothing to clear (writing a latest/anonymous sentinel could clear another
+      // session's live handoff — same own-vs-latest split as the L4 nudge).
+    } catch { /* best-effort — never block Phase 11 exit */ }
+  }
+
+  // TASK_943: Check ansuz inbox for fatigue_warning messages at every phase boundary
+  const exitInboxMessages = readAnsuzInboxMessages();
+
+  const exitResult = outputResult({
+    phase,
+    action: 'exit',
+    modules_loaded: phaseRecord.modules_loaded,
+    module_content: {},
+    checklist: phaseRecord.checklist_items,
+    inbox_messages: exitInboxMessages.length > 0 ? exitInboxMessages : null, // TASK_943: fatigue_warning delivery
+    warnings,
+    blocked: false,
+    block_reason: null,
+  });
+
+  // TASK_1400 + 2026-05-02 fix: Phase-exit auto-snapshot. Prior version only
+  // printed a nudge, leaving the snapshot write to the agent — which routinely
+  // missed it under momentum (see commit 852bb77f rationale). Now spawns the
+  // snapshot CLI as a detached process so the write is system-level, not
+  // instance-dependent. Errors swallowed; never blocks phase exit.
+  if ([1, 3, 9, 11].includes(phase) && !exitResult.blocked) {
+    const milestoneHint = (data && data.last_milestone)
+      ? data.last_milestone
+      : `Phase ${phase} exit`;
+    const fullMilestone = `Phase ${phase} exit: ${milestoneHint}`;
+    try {
+      const { spawn } = require('child_process');
+      const cli = path.join((CLI_PROJECT_PATH || BASE_DIR), '.specialist', 'Ansuz', 'tools', 'ansuz-handoff-snapshot.js');
+      if (fs.existsSync(cli)) {
+        const snapshotArgs = [cli, '--trigger=live_phase_exit', `--last-milestone=${fullMilestone}`];
+        // TASK_1829: forward our session id so the snapshot lands in THIS session's
+        // per-session slot (keeps the L4 own-slot check coherent across milestones).
+        const ownIds = resolveOwnHandoffSessionIds();
+        if (ownIds.length > 0) snapshotArgs.push(`--session-id=${ownIds[0]}`);
+        const child = spawn('node', snapshotArgs, {
+          detached: true,
+          stdio: 'ignore',
+          cwd: (CLI_PROJECT_PATH || BASE_DIR),
+          windowsHide: true,
+        });
+        child.unref();
+      }
+    } catch { /* best-effort — never block exit */ }
+    process.stdout.write(
+      `\n🔁 Phase ${phase} exit. Handoff auto-snapshot dispatched (live_phase_exit).\n`
+    );
+  }
+
+  return exitResult;
+}
+
+// ═══════════════════════════════════════
+//  Status
+// ═══════════════════════════════════════
+
+function statusTask(taskId) {
+  const chartPath = getChartReadPath(taskId);
+  const chart = readChart(taskId);
+
+  return outputResult({
+    task_id: taskId,
+    chart_exists: fs.existsSync(chartPath),
+    chief_complaint: chart.chief_complaint,
+    vitals: chart.vitals,
+    phases: Object.entries(chart.phases)
+      .sort(([a], [b]) => Number(a) - Number(b))
+      .map(([n, p]) => ({
+        phase: Number(n),
+        status: p.status,
+        entered_at: p.entered_at,
+        exited_at: p.exited_at,
+        checklist_result: p.checklist_result,
+        modules_loaded: p.modules_loaded,
+      })),
+    last_updated: chart.updated_at,
+  });
+}
+
+// ═══════════════════════════════════════
+//  Output helpers
+// ═══════════════════════════════════════
+
+function outputResult(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+  // TASK_1104: blocked enter/exit must surface as non-zero exit code so
+  // CI / headless dispatch can detect ritual failures without JSON parsing.
+  if (obj && obj.blocked === true) {
+    process.exitCode = 2;
+  }
+  return obj;
+}
+
+function fail(message) {
+  console.error(JSON.stringify({ error: message }, null, 2));
+  process.exit(1);
+}
+
+// ═══════════════════════════════════════
+//  CLI Argument Parser
+// ═══════════════════════════════════════
+
+function parseArgs(argv) {
+  const args = {};
+  for (const arg of argv) {
+    if (arg.startsWith('--')) {
+      const eqIdx = arg.indexOf('=');
+      if (eqIdx === -1) {
+        args[arg.slice(2)] = true;
+      } else {
+        const key = arg.slice(2, eqIdx);
+        const val = arg.slice(eqIdx + 1);
+        args[key] = val;
+      }
+    }
+  }
+  return args;
+}
+
+// ═══════════════════════════════════════
+//  Main CLI Entry Point
+// ═══════════════════════════════════════
+
+if (require.main === module) {
+  const [, , action, ...rest] = process.argv;
+  const args = parseArgs(rest);
+
+  if (!action) {
+    fail('Usage: node phase-gate.js <enter|exit|status|dump|note> [--phase=N] [--task=TASK_XXX] [--specialist=ansuz] [--data=\'{...}\'] [--thinking-tag=X,Y,Z]\n       node phase-gate.js dump --all');
+  }
+
+  // TASK_2374: append-only subcommand usage counter (measure-first; never throws).
+  try {
+    const f = process.env.KENAZ_USAGE_COUNTERS_FILE || resolveKenazPath('specialist', 'usage_counters.jsonl');
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.appendFileSync(f, JSON.stringify({ ts: new Date().toISOString(), kind: 'phase-gate', name: action, task: args.task || null }) + '\n');
+  } catch { /* counter must never break the gate */ }
+
+  switch (action) {
+    case 'note': {
+      // Merge a progress note (JSON object) from a local tmp file into the core chart.
+      // Worker writes note to a project-local path, then calls this subcommand to avoid
+      // cross-workspace Write tool calls (which trigger permission prompts across roots).
+      // --project-path is handled at module load via CLI_PROJECT_PATH; SESSION_DIR's
+      // PHYSICAL location stays on core, but TASK_2163's chart-path resolver keys the
+      // file within it by project identity, so sub-project ids don't collide.
+      if (!args.task) fail('--task=TASK_XXX is required');
+      if (!args['from-file']) fail('--from-file=<path> is required');
+
+      const noteFilePath = path.resolve(args['from-file']);
+      let noteRaw;
+      try {
+        noteRaw = fs.readFileSync(noteFilePath, 'utf8');
+        // Strip BOM -- PowerShell Set-Content writes UTF-8 with BOM by default
+        if (noteRaw.charCodeAt(0) === 0xFEFF) noteRaw = noteRaw.slice(1);
+      } catch (e) {
+        fail('--from-file read error: ' + e.message);
+      }
+
+      let noteEntry;
+      try {
+        noteEntry = JSON.parse(noteRaw);
+      } catch (e) {
+        fail('--from-file is not valid JSON: ' + e.message);
+      }
+      if (typeof noteEntry !== 'object' || noteEntry === null || Array.isArray(noteEntry)) {
+        fail('Progress note must be a JSON object, not an array or primitive');
+      }
+
+      // Read or create chart skeleton if absent (readChart returns createChart() when file missing)
+      const noteTaskId = args.task;
+      const chart = readChart(noteTaskId);
+      if (!Array.isArray(chart.progress_notes)) {
+        chart.progress_notes = [];
+      }
+      chart.progress_notes.push(noteEntry);
+
+      // Atomic write: write to .tmp then rename -- prevents partial-write corruption
+      const chartPath = getChartPath(noteTaskId);
+      const tmpPath = chartPath + '.tmp';
+      chartPathLib.ensureChartDir(chartPath);
+      chart.updated_at = new Date().toISOString();
+      fs.writeFileSync(tmpPath, JSON.stringify(chart, null, 2), 'utf8');
+      fs.renameSync(tmpPath, chartPath);
+
+      console.log('[phase-gate note] appended to ' + chartPath + ' (total notes: ' + chart.progress_notes.length + ')');
+      break;
+    }
+
+    case 'dump': {
+      if (!args.all) fail('--all is required: node phase-gate.js dump --all');
+      dumpPhases();
+      break;
+    }
+
+    case 'enter': {
+      if (!args.phase) fail('--phase=N is required');
+      const phase = parseInt(args.phase, 10);
+      if (isNaN(phase) || phase < 0) fail('--phase must be a non-negative integer');
+      // Phase 0 (session init) runs before any task exists — allow --task=none or omit
+      if (phase !== 0 && !args.task) fail('--task=TASK_XXX is required');
+      const enterTaskId = args.task || 'none';
+      // --specialist=ansuz|amelia|... → passed as agentRole to Phase 0 recall filter
+      enterPhase(phase, enterTaskId, args.specialist || null);
+      break;
+    }
+
+    case 'exit': {
+      if (!args.phase) fail('--phase=N is required');
+      const phase = parseInt(args.phase, 10);
+      if (isNaN(phase) || phase < 0) fail('--phase must be a non-negative integer');
+      // Phase 0 exit also allows --task=none
+      if (phase !== 0 && !args.task) fail('--task=TASK_XXX is required');
+      const exitTaskId = args.task || 'none';
+      let data = {};
+      if (args['data-file']) {
+        // Read JSON from file (PowerShell/Codex safe — avoids shell quoting issues)
+        try {
+          let raw = require('fs').readFileSync(args['data-file'], 'utf8');
+          // Strip BOM — PowerShell Set-Content writes UTF-8 with BOM by default
+          if (raw.charCodeAt(0) === 0xFEFF) raw = raw.slice(1);
+          data = JSON.parse(raw);
+        } catch (e) {
+          fail(`--data-file read/parse error: ${e.message}`);
+        }
+      } else if (args.data) {
+        try {
+          data = JSON.parse(args.data);
+        } catch (e) {
+          fail(`--data is not valid JSON: ${e.message}\nTip: On PowerShell/Codex, use --data-file=path.json instead of --data='{...}'`);
+        }
+      }
+      // TASK_1017: Parse --thinking-tag=X,Y,Z
+      const thinkingTags = args['thinking-tag']
+        ? String(args['thinking-tag']).split(',').map(t => t.trim()).filter(Boolean)
+        : null;
+      exitPhase(phase, exitTaskId, data, args.specialist || null, thinkingTags);
+      break;
+    }
+
+    case 'status': {
+      if (!args.task) fail('--task=TASK_XXX is required');
+      statusTask(args.task);
+      break;
+    }
+
+    default:
+      fail(`Unknown action: "${action}". Valid actions: enter, exit, status, dump, note`);
+  }
+}
+
+// ═══════════════════════════════════════
+//  Module exports (for programmatic use)
+// ═══════════════════════════════════════
+
+module.exports = {
+  enterPhase,
+  exitPhase,
+  statusTask,
+  readChart,
+  writeChart,
+  createChart,
+  readTaskScopePaths,
+  dumpPhases,
+  loadPhaseInstructions,
+  buildContextHints,
+  recallEpisodicMemory,
+  // TASK_869 seed protection
+  verifySeedIntegrity,
+  restoreSeedFromBackup,
+  mergeSeedAndGrowth,
+  writeSelfModelGrowth,
+  // TASK_923 blind spot guard injection
+  readBlindSpotGuards,
+  // TASK_2340: exposed for gate-shape tests
+  PHASE_CHECKLISTS,
+  PHASE_EXIT_RULES,
+};