kenaz 0.0.0-stage → 0.3.2

package/core/.specialist/tools/ansuz-boot-fast.js

@@ -0,0 +1,1120 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Ansuz Fast Boot — gateless Phase 0 for /Ansuz default mode.
+ *
+ * Replaces the phase-gate ceremony in fast mode. Pure Node, no MCP, no gate.
+ * Does only the three things boot actually needs:
+ *   1. identity injection — happens in session.js elixir prompt, NOT here
+ *   2. gather + print context banner (task stats + last-session handoff + B-001 priming)
+ *   3. archive last-session handoff (the one real side-effect from phase-gate enter)
+ *
+ * Why no gate: in fast mode the main thread does boot itself — there is no
+ * untrusted executor to verify, so gate validation would only check the
+ * script's own output (bookkeeping). Verified 2026-06-27 that nothing
+ * downstream reads the Phase 0 chart (failure-detector / context-injection
+ * don't touch it; the phase chain has no prior-phase requirement). The
+ * `--full` path keeps the gate for the Haiku sub-agent (untrusted) executor.
+ *
+ * Usage: node ansuz-boot-fast.js [--project-path PATH]
+ *   No --project-path → BASE = cwd (core repo, normal case).
+ *
+ * TASK_1757: register own session lease at boot; print peer awareness when
+ * other live sessions exist (single-session zero-noise invariant: no extra
+ * output when no peers). Also reads .kenaz/specialist/handoffs/*.json
+ * (multi-slot handoff) in addition to legacy ansuz_session_handoff.json.
+ */
+
+const fs = require('fs');
+const path = require('path');
+// Shared project identity resolver (TASK_1701): reads pin to find active project.
+const projectResolver = require('./lib/project-resolver');
+const http = require('http');
+const os = require('os');
+const cp = require('child_process');
+// TASK_2057: shared __kenaz_core__ token resolver (established cross-dir
+// require convention -- see .formation/tools/prompt.js/loop.js). Optional:
+// this script must still boot if an older install predates the export.
+let _resolveVirtualPath = null;
+try {
+  _resolveVirtualPath = require(path.join(__dirname, '..', '..', '.claude', 'hooks', 'core-resolve.js')).resolveVirtualPath;
+} catch { /* graceful degradation -- older installs without the export */ }
+
+// blind_spot.mirror — kept in sync with .specialist/Ansuz/elixir.yaml
+const BLIND_SPOT_B001 =
+  'B-001: checkpoint skipping under momentum; verify scope/acceptance match BEFORE creating tasks or dispatching.';
+
+// TASK_1701+1702: resolver exposes source so boot banner knows if pinned.
+const resolved = projectResolver.resolveProjectPath({ argv: process.argv.slice(2) });
+const BASE = resolved.projectPath;
+const PIN_SOURCE = resolved.source; // 'cli' | 'pin' | 'pin-heuristic' | 'cwd' | 'base'
+const IS_PINNED = PIN_SOURCE === 'cli' || PIN_SOURCE === 'pin';
+
+// Task dir resolution mirrors task-api: prefer .kenaz/tasks, fallback .collaboration/tasks
+function resolveTasksDir() {
+  const kenaz = path.join(BASE, '.kenaz', 'tasks');
+  if (fs.existsSync(kenaz)) return kenaz;
+  return path.join(BASE, '.collaboration', 'tasks');
+}
+
+function countTasks() {
+  const dir = resolveTasksDir();
+  const statuses = ['backlog', 'active', 'done', 'blocked', 'cancel'];
+  const counts = {};
+  for (const s of statuses) {
+    const d = path.join(dir, s);
+    let n = 0;
+    try {
+      if (fs.existsSync(d)) {
+        n = fs.readdirSync(d).filter((f) => f.endsWith('.yaml') || f.endsWith('.yml')).length;
+      }
+    } catch {
+      n = 0;
+    }
+    counts[s] = n;
+  }
+  const total = statuses.reduce((a, s) => a + counts[s], 0);
+  const cancel_rate = total > 0 ? counts.cancel / total : 0;
+  return { dir, counts, total, cancel_rate };
+}
+// -- TASK_1988: open cards inline --------------------------------------------
+//
+// MEASURED 2026-09-21: after the banner, the very first thing every Ansuz
+// session did was one more LLM turn + a task-api list + reading the open
+// cards, just to propose an agenda. With ~3 open cards that is ~300 B of
+// text bought with a whole round trip. Print them here: id, priority,
+// title (truncated), and the newest STATUS note if any, so the agenda can
+// be proposed in the first response. Hard caps keep a large backlog from
+// turning this into a dump: at most OPEN_CARDS_MAX cards, the rest as ids.
+const OPEN_CARDS_MAX = 8;
+const OPEN_CARD_TITLE_LEN = 90;
+const OPEN_CARD_STATUS_LEN = 140;
+
+function readCardHeader(file) {
+  let txt;
+  try { txt = fs.readFileSync(file, 'utf8'); } catch { return null; }
+  const pick = (key) => {
+    const m = txt.match(new RegExp('^' + key + ':[ \\t]*(.*)$', 'm'));
+    return m ? m[1].trim().replace(/^['"]|['"]$/g, '') : '';
+  };
+  // Newest technical_notes entry that starts with STATUS (progress-note convention).
+  let status = '';
+  const notes = txt.match(/^  - '?STATUS [^\n]*/gm);
+  if (notes && notes.length) {
+    // YAML single-quoted scalar: drop the opening quote, drop the closing quote
+    // (an ODD trailing run of ' = one closer after any '' escapes), then unescape ''.
+    let body = notes[notes.length - 1].replace(/^  - /, '');
+    if (body[0] === "'") {
+      body = body.slice(1);
+      const run = body.match(/'+$/);
+      if (run && run[0].length % 2 === 1) body = body.slice(0, -1);
+    }
+    status = body.replace(/''/g, "'");
+  }
+  return {
+    id: pick('id') || path.basename(file).split('_').slice(0, 2).join('_'),
+    priority: pick('priority'),
+    title: pick('title'),
+    status,
+  };
+}
+
+function openCardLines() {
+  const dir = resolveTasksDir();
+  const lines = [];
+  const cards = [];
+  for (const st of ['active', 'blocked', 'backlog']) {
+    const d = path.join(dir, st);
+    let files = [];
+    try { files = fs.existsSync(d) ? fs.readdirSync(d).filter((x) => /\.ya?ml$/.test(x)).sort() : []; } catch { files = []; }
+    for (const x of files) {
+      const h = readCardHeader(path.join(d, x));
+      if (h) cards.push({ st, ...h });
+    }
+  }
+  if (cards.length === 0) return lines;
+  const shown = cards.slice(0, OPEN_CARDS_MAX);
+  lines.push('📋 Open cards:');
+  for (const c of shown) {
+    const title = c.title.length > OPEN_CARD_TITLE_LEN ? c.title.slice(0, OPEN_CARD_TITLE_LEN) + '…' : c.title;
+    lines.push('   ' + c.id + ' [' + c.st + (c.priority ? ' ' + c.priority : '') + '] ' + title);
+    if (c.status) {
+      const tail = c.status.length > OPEN_CARD_STATUS_LEN ? c.status.slice(0, OPEN_CARD_STATUS_LEN) + '…' : c.status;
+      lines.push('      ↳ ' + tail);
+    }
+  }
+  if (cards.length > shown.length) {
+    lines.push('   +' + (cards.length - shown.length) + ' more: ' + cards.slice(shown.length).map((c) => c.id).join(', '));
+  }
+  return lines;
+}
+
+// -- TASK_1757: legacy handoff + multi-slot handoffs -------------------------
+
+function loadAndArchiveHandoff() {
+  const handoffPath = path.join(BASE, '.kenaz', 'specialist', 'ansuz_session_handoff.json');
+  if (!fs.existsSync(handoffPath)) return { loaded: false, summary: null };
+  let data = null;
+  try {
+    data = JSON.parse(fs.readFileSync(handoffPath, 'utf8'));
+  } catch (e) {
+    return { loaded: false, summary: null, error: `parse failed: ${e.message}` };
+  }
+  let archived = false;
+  try {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const archiveDir = path.join(BASE, '.kenaz', 'specialist', 'handoff_archive');
+    if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
+    fs.renameSync(handoffPath, path.join(archiveDir, `ansuz_session_handoff.${stamp}.json`));
+    archived = true;
+  } catch {
+    /* non-fatal: leave handoff in place if archive fails */
+  }
+  const isbar = (data && data.isbar) || {};
+  const sit = isbar.situation || {};
+  const rec = isbar.recommendation || {};
+  const assess = isbar.assessment || {};
+  const flat = (data && data.summary) || {};
+  return {
+    loaded: true,
+    archived,
+    summary: {
+      topic: sit.current_topic || (data && data.last_milestone) || flat.topic || null,
+      first_action: rec.first_action || flat.first_action || flat.next_action || null,
+      pending_decisions: sit.pending_decisions || flat.pending_decisions || null,
+      unfinished: assess.unfinished || flat.unfinished || null,
+    },
+  };
+}
+
+// Multi-slot handoffs: .kenaz/specialist/handoffs/*.json (TASK_1757)
+// TASK_2254 contract: slots are RENAMED into handoff_archive/ (content intact).
+// Consumers that must survive a boot (post-complete.js readLatestHandoff) fall
+// back to the newest handoff_archive/ slot by generated_at before the legacy slot.
+function loadMultiSlotHandoffs() {
+  const hDir = path.join(BASE, '.kenaz', 'specialist', 'handoffs');
+  if (!fs.existsSync(hDir)) {
+    try { fs.mkdirSync(hDir, { recursive: true }); } catch { /* ignore */ }
+    return [];
+  }
+  let files;
+  try { files = fs.readdirSync(hDir).filter(function(f) { return f.endsWith('.json'); }); }
+  catch { return []; }
+  const archiveDir = path.join(BASE, '.kenaz', 'specialist', 'handoff_archive');
+  const results = [];
+  for (const f of files) {
+    const fp = path.join(hDir, f);
+    let data = null;
+    try { data = JSON.parse(fs.readFileSync(fp, 'utf8')); } catch { continue; }
+    // TASK_1977 R3: capture recency BEFORE archiving (renameSync moves the
+    // file out from under fp) so the banner can select the newest slots.
+    let mtimeMs = 0;
+    try { mtimeMs = fs.statSync(fp).mtimeMs; } catch { /* fall back to 0 -- sorts last */ }
+    // Archive after reading -- ALL slots are archived regardless of what the
+    // banner ends up printing (TASK_1977 R3: archiving is unconditional).
+    try {
+      if (!fs.existsSync(archiveDir)) fs.mkdirSync(archiveDir, { recursive: true });
+      const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+      fs.renameSync(fp, path.join(archiveDir, f.replace('.json', '.' + stamp + '.json')));
+    } catch { /* non-fatal */ }
+    const isbar = (data && data.isbar) || {};
+    const sit = isbar.situation || {};
+    const rec = isbar.recommendation || {};
+    const assess = isbar.assessment || {};
+    const flat = (data && data.summary) || {};
+    results.push({
+      topic: sit.current_topic || (data && data.last_milestone) || flat.topic || null,
+      first_action: rec.first_action || flat.first_action || flat.next_action || null,
+      pending_decisions: sit.pending_decisions || flat.pending_decisions || null,
+      unfinished: assess.unfinished || flat.unfinished || null,
+      slot_file: f,
+      generated_at: (data && typeof data.generated_at === 'string') ? data.generated_at : null,
+      mtimeMs: mtimeMs,
+    });
+  }
+  return results;
+}
+
+// -- TASK_1977 R3: banner fan-out cap ----------------------------------------
+//
+// MEASURED 2026-09-20: a run of accumulated Codex sessions left 19 handoff
+// slots, most repeating the same pending_decisions text -- 33.8 KB printed
+// into the boot banner, the single largest boot injection. Archiving (above)
+// still processes every slot; this only caps what gets rendered:
+//   - sort newest-first (generated_at, falling back to file mtime)
+//   - print at most HANDOFF_MAX_FULL_SLOTS slots in full
+//   - skip (fold into the summary) any slot whose topic prefix duplicates
+//     an already-printed slot's topic prefix
+//   - one summary line for everything not printed in full
+
+const HANDOFF_MAX_FULL_SLOTS = 3;
+const HANDOFF_TOPIC_PREFIX_LEN = 60;
+
+function handoffTopicPrefix(topic) {
+  return String(topic == null ? '' : topic).trim().slice(0, HANDOFF_TOPIC_PREFIX_LEN);
+}
+
+function selectHandoffSlotsForBanner(slots) {
+  const sorted = [...slots].sort(function (a, b) {
+    const ta = a.generated_at ? Date.parse(a.generated_at) : NaN;
+    const tb = b.generated_at ? Date.parse(b.generated_at) : NaN;
+    const ka = Number.isFinite(ta) ? ta : (a.mtimeMs || 0);
+    const kb = Number.isFinite(tb) ? tb : (b.mtimeMs || 0);
+    return kb - ka;
+  });
+  const printed = [];
+  const printedPrefixes = new Set();
+  const rest = [];
+  for (const slot of sorted) {
+    const prefix = handoffTopicPrefix(slot.topic);
+    if (printed.length < HANDOFF_MAX_FULL_SLOTS && !printedPrefixes.has(prefix)) {
+      printed.push(slot);
+      printedPrefixes.add(prefix);
+    } else {
+      rest.push(slot);
+    }
+  }
+  let summaryLine = null;
+  if (rest.length > 0) {
+    const seen = new Set();
+    const restTopics = [];
+    for (const slot of rest) {
+      const label = fmt(slot.topic);
+      if (!seen.has(label)) { seen.add(label); restTopics.push(label); }
+    }
+    summaryLine = rest.length + ' more handoff slots archived (topics: ' + restTopics.join('; ') + ')';
+  }
+  return { printed: printed, rest: rest, summaryLine: summaryLine };
+}
+function fmt(v) {
+  if (v === null || v === undefined) return '—';
+  if (Array.isArray(v)) return v.length ? v.join('; ') : '—';
+  const str = String(v).trim();
+  return str.length ? str : '—';
+}
+
+// -- TASK_1702 pin helpers ---------------------------------------------------
+
+function getProjectName(projectPath) {
+  try {
+    var yp = path.join(projectPath, '.kenaz', 'project.yaml');
+    if (fs.existsSync(yp)) {
+      var raw = fs.readFileSync(yp, 'utf8');
+      // TASK_2081: the backslash in \s* was previously missing (matched the
+      // literal letter "s", not whitespace) -- worked by accident only
+      // because (.+) swallowed a leading space that .trim() then removed.
+      var m = raw.match(/^name:\s*(.+)$/m);
+      if (m) {
+        var name = m[1].trim().replace(/^(['"])(.*)\1$/, '$2');
+        if (name) return name;
+      }
+    }
+  } catch (e) { /* ignore */ }
+  return path.basename(projectPath);
+}
+
+function readProjectsJsonSync() {
+  try {
+    var p = path.join(os.homedir(), '.kenaz', 'projects.json');
+    if (!fs.existsSync(p)) return null;
+    var data = JSON.parse(fs.readFileSync(p, 'utf8'));
+    var currentId = data.currentProjectId;
+    if (!currentId || !Array.isArray(data.projects)) return null;
+    var proj = data.projects.find(function(pr) { return pr.id === currentId; });
+    if (!proj) return null;
+    // TASK_2057: proj.path for the core entry is the literal token
+    // "__kenaz_core__", not a real path -- resolve it, or the pin-mismatch
+    // warning above (main()) compares BASE against the unresolved token.
+    var resolvedPath = proj.path && _resolveVirtualPath ? _resolveVirtualPath(proj.path) : (proj.path || null);
+    return { currentProjectPath: resolvedPath, currentProjectName: proj.name || null };
+  } catch (e) { return null; }
+}
+
+function fetchCurrentProjectHttp() {
+  return new Promise(function(resolve) {
+    var req;
+    var timer = setTimeout(function() { req.destroy(); resolve(null); }, 1500);
+    req = require('http').get('http://127.0.0.1:18080/api/projects', function(res) {
+      var body = '';
+      res.on('data', function(d) { body += d; });
+      res.on('end', function() {
+        clearTimeout(timer);
+        try {
+          var data = JSON.parse(body);
+          var id = data.current_project_id || data.currentProjectId;
+          if (!id || !Array.isArray(data.projects)) { resolve(null); return; }
+          var proj = data.projects.find(function(pr) { return pr.id === id; });
+          resolve(proj ? { currentProjectPath: proj.path||null, currentProjectName: proj.name||null } : null);
+        } catch (e) { resolve(null); }
+      });
+    });
+    req.on('error', function() { clearTimeout(timer); resolve(null); });
+  });
+}
+
+async function getDashboardCurrentProject() {
+  var r = readProjectsJsonSync();
+  return r || fetchCurrentProjectHttp();
+}
+
+function normPath(p) {
+  if (!p) return '';
+  var r = path.resolve(p);
+  return process.platform === 'win32' ? r.toLowerCase() : r;
+}
+
+function readKnowledgeIndex(projectPath, max) {
+  max = max || 10;
+  var dir = path.join(projectPath, '.kenaz', 'knowledge');
+  if (!fs.existsSync(dir)) return [];
+  var files;
+  try { files = fs.readdirSync(dir).filter(function(f) { return f.endsWith('.md'); }).sort(); }
+  catch (e) { return []; }
+  var entries = [];
+  for (var i = 0; i < files.length && entries.length < max; i++) {
+    var h = null;
+    try {
+      var c = fs.readFileSync(path.join(dir, files[i]), 'utf8');
+      var m = c.match(/^[#]+ +(.+)$/m);
+      if (m) h = m[1].trim();
+    } catch (e) { /* ignore */ }
+    entries.push({ filename: files[i], heading: h });
+  }
+  return entries;
+}
+
+// -- TASK_1742: Huginn advisory section ----------------------------------------
+
+function readHuginnAdvisory(projectPath) {
+  const ap = path.join(projectPath, '.kenaz', 'specialist', 'huginn_advisory.jsonl');
+  if (!fs.existsSync(ap)) return { entries: [], unread: 0 };
+  let raw = '';
+  try { raw = fs.readFileSync(ap, 'utf8'); } catch (e) { return { entries: [], unread: 0 }; }
+  const cutoff = Date.now() - 14 * 24 * 60 * 60 * 1000;
+  const entries = [];
+  for (const line of raw.split(String.fromCharCode(10))) {
+    const t = line.trim(); if (!t) continue;
+    try { const obj = JSON.parse(t); if (obj.ts && new Date(obj.ts).getTime() >= cutoff) entries.push(obj); } catch (e) {}
+  }
+  entries.sort((a, b) => new Date(b.ts) - new Date(a.ts));
+  return { entries, unread: entries.filter(e => e.status === 'unread').length };
+}
+
+// -- TASK_1757: stream-lease registration and peer awareness ------------------
+
+function resolveStreamLeaseScript() {
+  var candidates = [
+    path.join(__dirname, 'stream-lease.js'),
+    path.join(BASE, '.specialist', 'tools', 'stream-lease.js'),
+  ];
+  var envSrc = process.env.KENAZ_SOURCE_DIR;
+  if (envSrc) candidates.unshift(path.join(envSrc, '.specialist', 'tools', 'stream-lease.js'));
+  for (var i = 0; i < candidates.length; i++) { if (fs.existsSync(candidates[i])) return candidates[i]; }
+  return null;
+}
+
+function registerOwnLease(slScript, convId) {
+  if (!slScript) return null;
+  try {
+    // Generate a session id: timestamp + pid
+    var sid = 'boot-' + Date.now() + '-' + process.pid;
+    var regArgs = [slScript, 'register',
+      '--session-id=' + sid,
+      '--pid=' + process.ppid, // M1.5 (TASK_1761): ppid = parent shell; hook self-heals to harness
+      '--phase=boot',
+      // TASK_1983 (R1): record which project this session is working on. BASE is
+      // already resolved above via projectResolver (CLI --project-path > pin > cwd).
+      '--project-path=' + BASE,
+    ];
+    // TASK_1764: pass conversation_id anchor so register writes current_stream.json
+    // (register only writes current_stream when --conversation-id is present or --scratch)
+    if (convId) regArgs.push('--conversation-id=' + convId);
+    var out = cp.execFileSync(process.execPath, regArgs, { timeout: 3000, encoding: 'utf8' });
+    // TASK_1863: register REUSES the existing lease when this conversation already
+    // holds one (ghost-lease fix) -- the effective session id is whatever register
+    // printed, not the boot-<ts>-<pid> we proposed. Parsing it keeps peer-awareness
+    // self-filtering correct (otherwise our own reused lease would show as a peer).
+    var m = /^registered (\S+) as /m.exec(out || '');
+    return (m && m[1]) || sid;
+  } catch { return null; }
+}
+
+function getPeerAwareness(slScript, ownSid) {
+  if (!slScript) return null;
+  try {
+    var sl = require(slScript);
+    var allLeases = sl.readAllLeases();
+    // Filter to OTHER live sessions
+    var peers = allLeases.filter(function(l) {
+      if (ownSid && l.session_id === ownSid) return false;
+      return sl.isSessionLive(l);
+    });
+    var orphans = allLeases.filter(function(l) {
+      if (ownSid && l.session_id === ownSid) return false;
+      return !sl.isSessionLive(l);
+    });
+    if (peers.length === 0 && orphans.length === 0) return null;
+    return { peers, orphans, sl };
+  } catch { return null; }
+}
+// The running harness's own session id when it exports one (Codex/Bifrost:
+// CODEX_SESSION_ID). null when absent or blank, so Claude sessions keep the
+// hook-hint chain unchanged.
+function harnessSessionIdFromEnv(env) {
+  var v = env && typeof env.CODEX_SESSION_ID === 'string' ? env.CODEX_SESSION_ID.trim() : '';
+  return v || null;
+}
+
+// TASK_2381: last_prompt_session.json is a single slot any session in the dir
+// overwrites. Adopt it only if it names THIS session: same id as the harness
+// env id, or (no env id) a transcript for that id exists under this cwd's
+// own transcript dir. Otherwise print no id rather than a foreign one.
+function hintNamesThisSession(hintId, env, cwd, home) {
+  if (!hintId) return false;
+  var own = env && typeof env.CLAUDE_CODE_SESSION_ID === 'string' ? env.CLAUDE_CODE_SESSION_ID.trim() : '';
+  if (own) return own === String(hintId);
+  try {
+    // Claude Code names the dir by replacing every non-alphanumeric char with '-'.
+    var dirName = path.resolve(cwd).replace(/[^a-zA-Z0-9]/g, '-');
+    return fs.existsSync(path.join(home || os.homedir(), '.claude', 'projects', dirName, String(hintId) + '.jsonl'));
+  } catch (_e) { return false; }
+}
+
+function parseArgValue(argv, name) {
+  for (const a of argv) {
+    if (a.indexOf(name + '=') === 0) return a.slice(name.length + 1);
+  }
+  return null;
+}
+
+// -- TASK_1997 R4: Wishing Well open-wish count on the boot banner -----------
+//
+// GET /api/wishes/list?status=pending -> {success, data: Wish[]}. 1 s
+// timeout — this must never meaningfully delay boot. On any failure
+// (Dashboard down, timeout, malformed body) resolve null so the banner
+// omits the line entirely; a successful-but-empty answer resolves [] so
+// the banner can print "0 open".
+
+const WISH_TIMEOUT_MS = 1000;
+const WISH_CONTENT_PREVIEW_LEN = 60;
+
+function fetchOpenWishes(baseUrl, timeoutMs, projectPath) {
+  return new Promise(function (resolve) {
+    let url;
+    try { url = new URL('/api/wishes/list?status=pending', baseUrl); } catch { resolve(null); return; }
+    // TASK_2063: when a --project-path pin is active, scope the query to it —
+    // otherwise resolve_wishes_path() (dashboard/src-tauri routes/wishes.rs)
+    // falls back to get_project_root(), i.e. whatever project the Dashboard
+    // currently has selected, not the pinned sub-project.
+    if (projectPath) {
+      const params = new URLSearchParams(url.search);
+      params.set('project_path', projectPath);
+      url.search = params.toString();
+    }
+    const req = http.request(
+      {
+        hostname: url.hostname,
+        port: url.port || 80,
+        path: url.pathname + url.search,
+        method: 'GET',
+        timeout: timeoutMs,
+      },
+      function (res) {
+        let data = '';
+        res.on('data', function (d) { data += d; });
+        res.on('end', function () {
+          try {
+            const parsed = JSON.parse(data);
+            if (!parsed || parsed.success === false || !Array.isArray(parsed.data)) { resolve(null); return; }
+            resolve(parsed.data);
+          } catch { resolve(null); }
+        });
+      },
+    );
+    req.on('timeout', function () { req.destroy(); });
+    req.on('error', function () { resolve(null); });
+    req.end();
+  });
+}
+
+// Pure formatter, split out from fetchOpenWishes for direct unit testing.
+// wishes === null (fetch failed / Dashboard down) -> null (banner omits the
+// line). wishes === [] (API answered with none) -> "0 open" line.
+function formatWishesLine(wishes) {
+  if (!Array.isArray(wishes)) return null;
+  if (wishes.length === 0) return '🪄 Wishes: 0 open';
+  const sorted = wishes.slice().sort(function (a, b) {
+    const ta = a && a.created_at ? Date.parse(a.created_at) : 0;
+    const tb = b && b.created_at ? Date.parse(b.created_at) : 0;
+    return (Number.isFinite(tb) ? tb : 0) - (Number.isFinite(ta) ? ta : 0);
+  });
+  const newest = sorted[0];
+  const content = newest && typeof newest.content === 'string' ? newest.content : '';
+  const preview = content.length > WISH_CONTENT_PREVIEW_LEN
+    ? content.slice(0, WISH_CONTENT_PREVIEW_LEN) + '…'
+    : content;
+  return '🪄 Wishes: ' + wishes.length + ' open (newest: ' + preview + ')';
+}
+
+// -- TASK_2006 R4: field-report auto-triage boot banner ----------------------
+//
+// Read-only over the task store (per-status YAML files) + a small boot-only
+// watermark file -- never touches field_reports.db directly (that's the
+// Rust mother's store; the task cards it writes via card_uncarded_reports
+// are the only thing this banner needs). "New since last boot" is tracked
+// by the highest TASK_NNN number already seen, not by timestamp: card ids
+// are assigned monotonically by the same auto-triage code, so a plain
+// numeric watermark is simpler and cheaper than parsing/parsing timestamps
+// out of YAML, and just as correct.
+
+const FIELD_REPORT_TASK_STATUSES = ['backlog', 'active', 'done', 'blocked', 'cancel'];
+const FIELD_REPORT_CARD_TAG = 'field-report';
+
+function fieldReportWatermarkPath() {
+  return path.join(BASE, '.kenaz', 'specialist', 'field_report_watermark.json');
+}
+
+// Scan every status dir for field-report cards (title prefix written by
+// inbox.rs's place_field_report_card: "[field-report:<kind>] ..."), return
+// their numeric TASK_NNN ids. A plain substring check on the tag is enough
+// here (cosmetic banner count, not a security boundary) -- exercised via
+// this pure function so the FS-scanning and counting logic are each
+// independently testable.
+function scanFieldReportCardIds(tasksDir) {
+  const ids = [];
+  for (const st of FIELD_REPORT_TASK_STATUSES) {
+    const d = path.join(tasksDir, st);
+    let files = [];
+    try { files = fs.existsSync(d) ? fs.readdirSync(d).filter((f) => /\.ya?ml$/.test(f)) : []; } catch { files = []; }
+    for (const f of files) {
+      let txt;
+      try { txt = fs.readFileSync(path.join(d, f), 'utf8'); } catch { continue; }
+      if (!txt.includes(FIELD_REPORT_CARD_TAG)) continue;
+      const idMatch = txt.match(/^id:\s*['"]?(TASK_\d+)/m) || f.match(/^(TASK_\d+)/);
+      if (!idMatch) continue;
+      const num = parseInt(idMatch[1].replace('TASK_', ''), 10);
+      if (Number.isFinite(num)) ids.push(num);
+    }
+  }
+  return ids;
+}
+
+// Pure counting logic, split out for unit testing (mirrors formatWishesLine's
+// split from fetchOpenWishes). `watermark === null` means "no prior boot
+// recorded" -- establish a baseline instead of reporting every existing card
+// as new (avoids a flood on the very first boot after this feature ships,
+// when backfill (R3) may have just carded many pre-existing reports at once).
+function computeNewFieldReportCount(ids, watermark) {
+  const max = ids.length ? Math.max(...ids) : (typeof watermark === 'number' ? watermark : 0);
+  if (watermark === null || watermark === undefined) {
+    return { newCount: 0, nextWatermark: max };
+  }
+  const newCount = ids.filter((n) => n > watermark).length;
+  return { newCount, nextWatermark: Math.max(watermark, max) };
+}
+
+function readFieldReportWatermark() {
+  try {
+    const data = JSON.parse(fs.readFileSync(fieldReportWatermarkPath(), 'utf8'));
+    return typeof data.last_seen_max_id === 'number' ? data.last_seen_max_id : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeFieldReportWatermark(value) {
+  try {
+    const p = fieldReportWatermarkPath();
+    const dir = path.dirname(p);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(p, JSON.stringify({ last_seen_max_id: value }));
+  } catch {
+    /* non-fatal: banner just won't advance the watermark this boot */
+  }
+}
+
+// TASK_2040: mother-side triage duty (WISHING WELL mandate) — field-report
+// cards (blockers, project-scope wishes, feature proposals alike) tagged
+// `needs-triage` by the companion Rust routing are judged at boot: adopt
+// or decline, never left to accumulate silently. This counts currently
+// OPEN (unresolved) needs-triage cards, not "new since last boot" like
+// scanFieldReportCardIds/computeNewFieldReportCount above -- a card stays
+// counted every boot until it is triaged (moved to done/cancel), which is
+// the point: it is a standing worklist, not a one-time notification.
+const NEEDS_TRIAGE_TAG = 'needs-triage';
+const OPEN_TASK_STATUSES = ['backlog', 'active', 'blocked'];
+
+// Same substring-match convention as scanFieldReportCardIds (cosmetic
+// banner count, not a security boundary): matches the tag whether it lands
+// in a YAML `tags:` list entry or a title prefix.
+function countOpenNeedsTriageCards(tasksDir, { heimdall = false } = {}) {
+  let count = 0;
+  for (const st of OPEN_TASK_STATUSES) {
+    const d = path.join(tasksDir, st);
+    let files = [];
+    try { files = fs.existsSync(d) ? fs.readdirSync(d).filter((f) => /\.ya?ml$/.test(f)) : []; } catch { files = []; }
+    for (const f of files) {
+      let txt;
+      try { txt = fs.readFileSync(path.join(d, f), 'utf8'); } catch { continue; }
+      if (!txt.includes(NEEDS_TRIAGE_TAG)) continue;
+      // TASK_2245: heimdall cards have their own banner line; keep them out of
+      // the field-report count (heimdall=false) and count only them (true).
+      if (hasYamlTag(txt, 'heimdall') === heimdall) count++;
+    }
+  }
+  return count;
+}
+
+// Tag membership in a task YAML (block list or inline list), not a substring
+// match -- a description mentioning "heimdall" must not count.
+function hasYamlTag(txt, tag) {
+  return new RegExp('^\\s*-\\s*[\'"]?' + tag + '[\'"]?\\s*$', 'm').test(txt)
+    || new RegExp('^tags:.*[\\[,\\s\'"]' + tag + '[\\],\\s\'"]', 'm').test(txt);
+}
+
+// TASK_2245: Heimdall findings land as needs-triage cards; one banner line
+// with the open count, omitted at 0 (pure, mirrors formatFieldReportLine).
+function formatHeimdallTriageLine(count) {
+  if (!(count > 0)) return null;
+  return '🔭 Heimdall: ' + count + ' finding(s) awaiting triage (tag needs-triage,heimdall)';
+}
+
+// TASK_2363: the post-commit hook only appends one JSON line per commit to
+// .kenaz/specialist/heimdall_commits.jsonl ({"sha":..,"at":<unix secs>}); the
+// heimdall skill writes heimdall_last_scan.json ({"at":<unix secs>}) when an
+// in-session scan finishes. Commits since the last scan = records newer than it.
+function countCommitsSinceHeimdallScan(base) {
+  const dir = path.join(base, '.kenaz', 'specialist');
+  let lastAt = 0;
+  try { lastAt = Number(JSON.parse(fs.readFileSync(path.join(dir, 'heimdall_last_scan.json'), 'utf8')).at) || 0; } catch { /* no scan yet */ }
+  let txt;
+  try { txt = fs.readFileSync(path.join(dir, 'heimdall_commits.jsonl'), 'utf8'); } catch { return 0; }
+  let n = 0;
+  for (const l of txt.split('\n')) {
+    if (!l.trim()) continue;
+    try { if (Number(JSON.parse(l).at) > lastAt) n++; } catch { /* skip torn line */ }
+  }
+  return n;
+}
+
+function formatHeimdallScanLine(count) {
+  if (!(count > 0)) return null;
+  return '🔭 ' + count + ' commits since last Heimdall scan (run the heimdall skill in-session to scan)';
+}
+
+// Pure formatter, split out for direct unit testing (mirrors
+// formatWishesLine). Omitted (null) only when BOTH counts are 0 -- the
+// existing "new field-report cards" zero-noise convention, extended to
+// also cover the needs-triage count.
+function formatFieldReportLine(newCount, needsTriageCount) {
+  if (newCount <= 0 && needsTriageCount <= 0) return null;
+  const parts = [];
+  if (newCount > 0) parts.push(newCount + ' new card(s) since last boot');
+  if (needsTriageCount > 0) parts.push(needsTriageCount + ' needing triage');
+  return '📥 Field reports: ' + parts.join(', ');
+}
+
+// Omitted when both counts are 0 (banner zero-noise convention -- see
+// wishesLine/openCardLines).
+function fieldReportBannerLine() {
+  const tasksDir = resolveTasksDir();
+  const ids = scanFieldReportCardIds(tasksDir);
+  const watermark = readFieldReportWatermark();
+  const { newCount, nextWatermark } = computeNewFieldReportCount(ids, watermark);
+  writeFieldReportWatermark(nextWatermark);
+  const needsTriageCount = countOpenNeedsTriageCards(tasksDir);
+  return formatFieldReportLine(newCount, needsTriageCount);
+}
+
+// -- TASK_2044: surface dead graph DBs loudly ---------------------------------
+//
+// Incident 2026-09-26: the KenazAI Synapse graph was unopenable from 08:13Z
+// and only surfaced when a new tool was smoke-tested; Cortex meta_graph
+// (~/.kenaz/cortex/meta_graph/graph) failed to open with "invalid
+// unordered_map<K, T> key" since 2026-09-03 (1008 WARN lines) and nothing
+// surfaced it for 23+ days. Both logged only as WARN. This is the one
+// surface every /Ansuz session reads, so both failures get a loud
+// ANOMALY-style line here. File reads only -- no MCP, no DB open -- boot
+// must stay cheap and must never throw.
+//
+// TASK_2048: meta_graph itself has been retired (dev/CORTEX_META_GRAPH_ASSESSMENT.md
+// -- dead since 2026-04-13, zero live consumers, ~4k lines removed). The
+// "Cortex auto-sync failed/panicked" detector below is KEPT as-is (renamed
+// CORTEX_SYNC_ERROR, was CORTEX_META_GRAPH_ERROR) because Cortex auto-sync
+// still runs -- it now only syncs global_memory.db, but that sync can still
+// fail (e.g. a locked/corrupt global_memory.db) and this is still the
+// cheapest place to surface it. The dbPath shown is whatever the failure
+// line itself names, not necessarily meta_graph anymore.
+
+// Bounded tail read (last ~256 KB) so boot never pays for a multi-MB log.
+const CORTEX_LOG_TAIL_BYTES = 256 * 1024;
+// TERMINAL outcomes only ("completed" / "failed:" / "task panicked:") --
+// deliberately excludes the non-terminal lines the Rust side also logs under
+// "Cortex auto-sync" (features/synapse/index.rs: "Triggering Cortex
+// auto-sync for <path>" at the START of every sync; features/cortex/sync.rs:
+// "Cortex auto-sync already in progress, skipping" / "...skipped: no tokio
+// runtime..."). Matching those would let a trigger/in-progress/skipped line
+// that lands AFTER a real failure (e.g. boot polling between the next
+// reindex's trigger and its result) falsely read as "not a failure" and
+// clear a still-broken sync.
+const CORTEX_SYNC_LINE_RE = /Cortex auto-sync (completed|failed:|task panicked:)/;
+const CORTEX_DB_OPEN_FAILED_RE = /DB open failed \(([^)]*)\)/;
+
+// GEN-008/009: path resolved per-platform via env, never hard-coded. Mirrors
+// backend_log_dir() (dashboard/src-tauri/src/infrastructure/logging.rs),
+// which resolves via the Rust `dirs` crate's data_local_dir(): %LOCALAPPDATA%
+// on Windows, ~/Library/Application Support on macOS, $XDG_DATA_HOME (else
+// ~/.local/share) on Linux.
+function resolveBackendLogPath() {
+  try {
+    if (process.platform === 'win32') {
+      const base = process.env.LOCALAPPDATA;
+      return base ? path.join(base, 'Kenaz Dashboard', 'backend.log') : null;
+    }
+    if (process.platform === 'darwin') {
+      const home = os.homedir();
+      return home ? path.join(home, 'Library', 'Application Support', 'Kenaz Dashboard', 'backend.log') : null;
+    }
+    const xdg = process.env.XDG_DATA_HOME;
+    if (xdg) return path.join(xdg, 'Kenaz Dashboard', 'backend.log');
+    const home = os.homedir();
+    return home ? path.join(home, '.local', 'share', 'Kenaz Dashboard', 'backend.log') : null;
+  } catch {
+    return null;
+  }
+}
+
+// Reads only the last `maxBytes` of `logPath`. Missing file / any read error
+// -> null. Split out from the caller so it's directly unit-testable against
+// a temp file without touching the real backend.log (GEN-007/008).
+function readBackendLogTailSync(logPath, maxBytes) {
+  let stat;
+  try { stat = fs.statSync(logPath); } catch { return null; }
+  const size = stat.size;
+  const start = size > maxBytes ? size - maxBytes : 0;
+  let fd;
+  try { fd = fs.openSync(logPath, 'r'); } catch { return null; }
+  try {
+    const len = size - start;
+    if (len <= 0) return '';
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, start);
+    return buf.toString('utf8');
+  } catch {
+    return null;
+  } finally {
+    try { fs.closeSync(fd); } catch { /* ignore */ }
+  }
+}
+
+// Pure formatter over an already-read log tail -- split out for direct unit
+// testing. Looks only at TERMINAL "Cortex auto-sync" outcome lines (the
+// wrapper in dashboard/src-tauri/src/features/cortex/sync.rs::trigger_auto_sync,
+// which logs "Cortex auto-sync completed" on success, or "Cortex auto-sync
+// failed: <err>" / "Cortex auto-sync task panicked: <err>" on failure, where
+// <err> is "DB open failed (<path>): ..." when the DB the sync touches
+// (TASK_2048: global_memory.db -- meta_graph has been retired) won't open)
+// -- see CORTEX_SYNC_LINE_RE for why non-terminal lines
+// (trigger/in-progress/skipped) are deliberately excluded. The MOST RECENT
+// such terminal line decides the verdict, so a later success line clears a
+// prior failure.
+function formatCortexSyncAnomaly(tailText) {
+  if (typeof tailText !== 'string' || tailText.length === 0) return null;
+  const lines = tailText.split(/\r?\n/).filter((l) => CORTEX_SYNC_LINE_RE.test(l));
+  if (lines.length === 0) return null;
+  const mostRecent = lines[lines.length - 1];
+  const m = CORTEX_DB_OPEN_FAILED_RE.exec(mostRecent);
+  if (!m) return null;
+  const dbPath = m[1];
+  const failureCount = lines.filter((l) => CORTEX_DB_OPEN_FAILED_RE.test(l)).length;
+  return '⚠️ ANOMALY: CORTEX_SYNC_ERROR — DB open failed: ' + dbPath +
+    ' (' + failureCount + ' failure(s) in backend.log tail) — check backend.log';
+}
+
+// logPathOverride lets tests point this at a fixture file instead of the
+// real backend.log. Any failure (unresolvable path, missing file, read
+// error) -> null, never throws.
+function cortexSyncAnomalyLine(logPathOverride) {
+  try {
+    const logPath = logPathOverride || resolveBackendLogPath();
+    if (!logPath) return null;
+    const tail = readBackendLogTailSync(logPath, CORTEX_LOG_TAIL_BYTES);
+    if (tail === null) return null;
+    return formatCortexSyncAnomaly(tail);
+  } catch {
+    return null;
+  }
+}
+
+// TASK_2388: cwd is not a Kenaz project and nothing is pinned/passed -> the resolver fell back to
+// the install's own BASE_DIR. Printing that project's streams/tasks here is another project's data.
+function isOutsideAnyProject(source, cwd, base) {
+  if (source !== 'base') return false;
+  const rel = path.relative(path.resolve(base), path.resolve(cwd));
+  return rel.startsWith('..') || path.isAbsolute(rel);
+}
+
+async function main() {
+  if (isOutsideAnyProject(PIN_SOURCE, process.cwd(), BASE)) {
+    process.stdout.write('ᚨ Ansuz: not inside a Kenaz project (cwd=' + process.cwd() + ').' + String.fromCharCode(10) +
+      'cd into a project, or run /kenaz init to set this directory up.' + String.fromCharCode(10));
+    return;
+  }
+  const tasks = countTasks();
+  const handoff = loadAndArchiveHandoff();
+  const multiHandoffs = loadMultiSlotHandoffs();
+  const c = tasks.counts;
+  const pct = Math.round(tasks.cancel_rate * 100);
+
+  // TASK_1757: register own lease (side-effect; silent on failure)
+  var slScript = resolveStreamLeaseScript();
+  // TASK_1764: derive stable conversation_id from transcript_path basename (stable across resume).
+  // TASK_1863: --conversation-id= overrides the transcript-derived id (same injectable-seam
+  // pattern as --mcp-base-url) so the lease-reuse behavior is testable in a sandbox
+  // where no transcript exists.
+  var _convId = parseArgValue(process.argv.slice(2), '--conversation-id');
+  // Codex (Bifrost) exports its own session id; every hint file below is written
+  // by CLAUDE hooks and belongs to some Claude session, so inside Codex they
+  // returned the wrong id (peer report 2026-10-05: replies bound to the boot id
+  // were lost). The harness's own id wins over any hint.
+  if (!_convId) _convId = harnessSessionIdFromEnv(process.env);
+  if (!_convId && process.env.CLAUDE_CODE_SESSION_ID && process.env.CLAUDE_CODE_SESSION_ID.trim()) _convId = process.env.CLAUDE_CODE_SESSION_ID.trim();
+  // TASK_2218: prefer the REAL hook-provided session id over guessing -- the
+  // newest-*.jsonl-mtime-in-cwd guess below silently resolves to ANOTHER
+  // session's transcript whenever two sessions share a cwd (field report:
+  // installed user, every session's cwd = kenaz-core; boot mis-derived
+  // conversation_id, so ansuz_handoff_snapshot wrote to the OTHER session's
+  // slot). .claude/hooks/ansuz-session-pin.js writes this sidecar on every
+  // UserPromptSubmit with THIS turn's real {session_id, written_at} -- read
+  // here moments later, same turn, via the model's own Bash tool call. Same
+  // dir .claude/hooks/ reads CLAUDE_PROJECT_DIR from (not BASE, which may
+  // already be pin-resolved to a sub-project the hook's cwd-keyed sidecar
+  // never saw) -- see that hook's own module doc.
+  var HOOK_HINT_FRESH_MS = 5 * 60 * 1000; // 5 min: same-turn hook write -> this read
+  // TASK_2222: the single-slot hint below is overwritten by EVERY session's
+  // EVERY turn -- a second live session prompting in the same cwd between
+  // this hook's write and this Bash call's read clobbers it, handing boot
+  // the WRONG session id (the actual bug this task fixes; real fix is the
+  // caller passing --conversation-id explicitly, sourced from THIS session's
+  // own turn-context output, which cannot be clobbered). Before trusting the
+  // single slot, check the keyed-per-session hints
+  // (.kenaz/specialist/prompt_hints/<session_id>.json, written alongside the
+  // single slot by the same hook) -- each session writes only its own file,
+  // so they cannot clobber each other. Exactly one fresh keyed hint is as
+  // trustworthy as the single slot used to assume it always was; more than
+  // one is genuine ambiguity (two sessions both just prompted) that must NOT
+  // be guessed away, so it falls through instead of picking either one.
+  if (!_convId) try {
+    var _hintsDir = path.join(process.env.CLAUDE_PROJECT_DIR || process.cwd(), '.kenaz', 'specialist', 'prompt_hints');
+    if (fs.existsSync(_hintsDir)) {
+      var _freshHints = [];
+      for (const _f of fs.readdirSync(_hintsDir)) {
+        if (!_f.endsWith('.json')) continue;
+        try {
+          var _kh = JSON.parse(fs.readFileSync(path.join(_hintsDir, _f), 'utf8'));
+          if (_kh && _kh.session_id && Date.now() - (_kh.written_at || 0) < HOOK_HINT_FRESH_MS) {
+            _freshHints.push(String(_kh.session_id));
+          }
+        } catch (_khe) { /* ignore unreadable/corrupt entry */ }
+      }
+      if (_freshHints.length === 1) _convId = _freshHints[0];
+      // length 0 -> nothing to use yet, fall through. length > 1 -> ambiguous
+      // (another session is also live) -- fall through rather than guess.
+    }
+  } catch (_phe) {}
+  if (!_convId) try {
+    var _hookProjectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    var _hintPath = path.join(_hookProjectDir, '.kenaz', 'specialist', 'last_prompt_session.json');
+    if (fs.existsSync(_hintPath)) {
+      var _hint = JSON.parse(fs.readFileSync(_hintPath, 'utf8'));
+      if (_hint && _hint.session_id && Date.now() - (_hint.written_at || 0) < HOOK_HINT_FRESH_MS &&
+          hintNamesThisSession(_hint.session_id, process.env, process.cwd())) {
+        _convId = String(_hint.session_id);
+      }
+    }
+  } catch (_he) {}
+  if (!_convId) try {
+    var _sessionMod = require('./session.js');
+    // Claude Code files the transcript under the directory the session was
+    // started in (this script's cwd), not under the pinned project. Looking
+    // only under BASE found nothing for a pinned sub-project, so the lease had
+    // no conversation id and every handoff snapshot opened a new slot
+    // (field reports e787bb45 / 10ee9c09, TASK_2012).
+    //
+    // TASK_2218: last-resort fallback only -- a GUESS (newest mtime among
+    // potentially several live *.jsonl files in the same project dir), kept
+    // for non-hook-driven invocations (manual CLI run, headless dispatch, a
+    // non-Claude driver) where no hook ever wrote the sidecar above.
+    var _txPath = null;
+    if (_sessionMod.findConversationLog) {
+      _txPath = _sessionMod.findConversationLog(process.cwd());
+      if (!_txPath && path.resolve(BASE) !== path.resolve(process.cwd())) _txPath = _sessionMod.findConversationLog(BASE);
+    }
+    if (_txPath) _convId = path.basename(_txPath, '.jsonl');
+  } catch (_ce) {}
+  var ownSid = registerOwnLease(slScript, _convId);
+  // Peer awareness: only computed if registration succeeded or slScript found
+  var peerData = slScript ? getPeerAwareness(slScript, ownSid) : null;
+
+  const lines = [];
+  lines.push('═══ ᚨ Ansuz · 快速 Boot (gateless) ═══');
+  // The MCP handoff tool cannot tell which session called it; current_stream.json
+  // is a single global slot, so it mints a new ansuz-prompt-<ts> slot whenever that
+  // pointer is missing or belongs to another session. Ansuz passes this id
+  // explicitly as session_id instead (elixir HANDOFF mandate).
+  if (_convId) lines.push('[session] conversation_id=' + _convId + '  (pass as session_id to ansuz_handoff_snapshot)');
+
+  // -- TASK_1702 R2: pin banner -------------------------------------------
+  if (IS_PINNED) {
+    const projName = getProjectName(BASE);
+    const srcLabel = PIN_SOURCE === 'cli' ? 'cli' : 'pin';
+    lines.push('[pin:' + srcLabel + '] Session bound: ' + projName + '  ' + BASE);
+
+    // mismatch warning (async, offline-safe)
+    let dashProj = null;
+    try { dashProj = await getDashboardCurrentProject(); } catch (e) { /* silent */ }
+    if (dashProj && dashProj.currentProjectPath) {
+      if (normPath(dashProj.currentProjectPath) !== normPath(BASE)) {
+        lines.push('[warn] Dashboard current project (' +
+          (dashProj.currentProjectName || dashProj.currentProjectPath) +
+          ') != pinned project -- pass projectPath on all MCP calls');
+      }
+    }
+
+    // knowledge index
+    const knowledge = readKnowledgeIndex(BASE, 10);
+    if (knowledge.length > 0) {
+      lines.push('[knowledge] ' + projName + ' .kenaz/knowledge/:');
+      for (const k of knowledge) {
+        lines.push('   ' + k.filename + (k.heading ? ' -- ' + k.heading : ''));
+      }
+    }
+  }
+
+  // TASK_1757: peer awareness banner (zero-noise when no peers)
+  if (peerData && (peerData.peers.length > 0 || peerData.orphans.length > 0)) {
+    lines.push('[Multi-Ansuz] Other sessions detected:');
+    for (const peer of peerData.peers) {
+      var ageMs = peerData.sl.heartbeatAgeMs(peer);
+      var ageSec = ageMs === Infinity ? 'inf' : Math.round(ageMs / 1000) + 's';
+      var tasks_s = (peer.claimed_tasks && peer.claimed_tasks.length) ? '  tasks=' + peer.claimed_tasks.join(',') : '';
+      var scope_s = (peer.scope_leases && peer.scope_leases.length) ? '  scope=' + peer.scope_leases.join(',') : '';
+      lines.push('   [live] ' + (peer.label || peer.session_id) + '  pid=' + peer.pid + '  heartbeat=' + ageSec + ' ago' + tasks_s + scope_s);
+    }
+    for (const orphan of peerData.orphans) {
+      var oAge = peerData.sl.heartbeatAgeMs(orphan);
+      // TASK_1791: classification basis is heartbeat freshness, NOT pid liveness -- the
+      // registered pid exits by design (lease-touch.js renews the heartbeat). Suggest
+      // targeted reap (reap --session-id): bulk `reap` only acts at >=24h heartbeat age.
+      // TASK_1792: stale threshold raised 45min -> 8h (stream-lease LIVENESS_THRESHOLD_MS,
+      // rendered dynamically below). Heartbeats only advance on UserPromptSubmit, so a live
+      // peer running long dispatch chains can idle for hours without a prompt; at 45min this
+      // banner printed an executable clear command against live sessions. Only leases idle
+      // beyond 8h -- far past any realistic no-prompt working stretch -- get a clear
+      // suggestion now. isSessionLive is also heartbeat-only since TASK_1792 (pid recycling
+      // made dead sessions probe live forever), so [stale] here == reapable, no dead zone.
+      var oAgeStr = peerData.sl.fmtAge ? peerData.sl.fmtAge(oAge) : (oAge === Infinity ? 'inf' : Math.round(oAge / 1000) + 's');
+      var oThrStr = (peerData.sl.fmtAge && peerData.sl.LIVENESS_THRESHOLD_MS) ? peerData.sl.fmtAge(peerData.sl.LIVENESS_THRESHOLD_MS) : '8.0h';
+      lines.push('   [stale] ' + (orphan.label || orphan.session_id) + '  last-heartbeat=' + oAgeStr + ' ago (no heartbeat within ' + oThrStr + ') -- clear: node .specialist/tools/stream-lease.js reap --session-id=' + orphan.session_id);
+    }
+  }
+  lines.push(
+    `📊 任務 — total ${tasks.total} | active ${c.active} | backlog ${c.backlog} | ` +
+      `blocked ${c.blocked} | done ${c.done} | cancelled ${c.cancel} (${pct}%)`,
+  );
+  if (tasks.cancel_rate >= 0.7 && tasks.total >= 50) {
+    lines.push(
+      `⚠️ ANOMALY: HIGH_CANCEL_RATE — ${pct}% of ${tasks.total} tasks cancelled (${c.cancel}/${tasks.total})`,
+    );
+  }
+  // TASK_2044: Cortex auto-sync failure (TASK_2048: global_memory.db only, meta_graph retired).
+  // Both omitted when healthy (zero-noise).
+  const cortexAnomaly = cortexSyncAnomalyLine();
+  if (cortexAnomaly) lines.push(cortexAnomaly);
+  // TASK_1997 R4: open-wish count. mcpBase reuses the same override seam as
+  // the --mcp-base-url= / KENAZ_MCP_BASE_URL seam.
+  const mcpBase =
+    parseArgValue(process.argv.slice(2), '--mcp-base-url') ||
+    process.env.KENAZ_MCP_BASE_URL ||
+    'http://127.0.0.1:18080';
+  // TASK_2063: pass the resolved pin (same value used for the pin banner
+  // line above) so the query is scoped to the bound project when pinned.
+  const wishesLine = formatWishesLine(await fetchOpenWishes(mcpBase, WISH_TIMEOUT_MS, IS_PINNED ? BASE : null));
+  if (wishesLine) lines.push(wishesLine);
+  // TASK_2006 R4: field-report auto-triage banner (omitted when N=0).
+  const fieldReportLine = fieldReportBannerLine();
+  if (fieldReportLine) lines.push(fieldReportLine);
+  const heimdallLine = formatHeimdallTriageLine(countOpenNeedsTriageCards(resolveTasksDir(), { heimdall: true }));
+  if (heimdallLine) lines.push(heimdallLine);
+  const heimdallScanLine = formatHeimdallScanLine(countCommitsSinceHeimdallScan(BASE));
+  if (heimdallScanLine) lines.push(heimdallScanLine);
+  for (const l of openCardLines()) lines.push(l);
+  if (handoff.loaded) {
+    const s = handoff.summary;
+    // TASK_1988 banner cut: topic + unfinished only. first_action is derived
+    // from the same commit line as topic ("Continue from: <topic>") and
+    // pending_decisions repeats the open task's title -- both were pure bytes.
+    lines.push(`📜 上一世 Handoff${handoff.archived ? ' (已歸檔)' : ''}: ${fmt(s.topic)}`);
+    if (s.unfinished) lines.push(`   unfinished: ${fmt(s.unfinished)}`);
+  } else if (multiHandoffs.length === 0) {
+    // TASK_1837: "無" only when BOTH the (retired) legacy slot and the multi-slot
+    // directory are empty — previously this printed "上一世 Handoff: 無" from the
+    // legacy file alone and then listed N per-session slots right below it.
+    lines.push('📜 上一世 Handoff: 無');
+  }
+  // TASK_1757: multi-slot handoffs -- TASK_1977 R3: cap fan-out to at most
+  // HANDOFF_MAX_FULL_SLOTS full slots (newest first, topic-deduped); fold
+  // the rest into one summary line. All slots were already archived above
+  // regardless of this selection.
+  const handoffSelection = selectHandoffSlotsForBanner(multiHandoffs);
+  for (const mh of handoffSelection.printed) {
+    // TASK_1988: one line per slot (topic; unfinished when it adds something).
+    const unf = mh.unfinished && fmt(mh.unfinished) !== fmt(mh.topic) ? '  — unfinished: ' + fmt(mh.unfinished) : '';
+    lines.push(`📜 Handoff [${String(mh.slot_file).slice(0, 8)}]: ${fmt(mh.topic)}${unf}`);
+  }
+  if (handoffSelection.summaryLine) lines.push(`📜 ${handoffSelection.summaryLine}`);
+  // -- TASK_1742 advisory banner --
+  const adv = readHuginnAdvisory(BASE);
+  if (adv.entries.length > 0) {
+    lines.push('[Huginn Advisory] ' + adv.unread + '/' + adv.entries.length + ' unread (last 14d) -- advisory->task requires live baseline verification');
+    for (const e of adv.entries.slice(0, 3)) {
+      lines.push('   ' + e.ts.slice(0, 10) + ' ' + (e.title || '(untitled)'));
+    }
+  }
+  lines.push('（快速 boot · 無 gate · 完整 ceremony 用 /Ansuz --full）');
+  process.stdout.write(lines.join(String.fromCharCode(10)) + String.fromCharCode(10));
+}
+
+// TASK_1997: guarded so this module can be require()'d for unit testing
+// (fetchOpenWishes / formatWishesLine) without running the full boot
+// sequence as a side effect. Always run as `node ansuz-boot-fast.js` in
+// production, so require.main === module there and behavior is unchanged.
+if (require.main === module) {
+  main().catch(function() {
+    // Catastrophic failure: still emit basic banner
+    process.stdout.write('=== Ansuz * Quick Boot (gateless) ===' + String.fromCharCode(10) + '[boot error -- see stderr]' + String.fromCharCode(10));
+  });
+}
+
+module.exports = {
+  isOutsideAnyProject,
+  harnessSessionIdFromEnv,
+  hintNamesThisSession,
+  fetchOpenWishes,
+  formatWishesLine,
+  scanFieldReportCardIds,
+  computeNewFieldReportCount,
+  countOpenNeedsTriageCards,
+  formatFieldReportLine,
+  formatHeimdallTriageLine,
+  countCommitsSinceHeimdallScan,
+  formatHeimdallScanLine,
+  resolveBackendLogPath,
+  readBackendLogTailSync,
+  formatCortexSyncAnomaly,
+  cortexSyncAnomalyLine,
+  readProjectsJsonSync, // TASK_2057: exported for __kenaz_core__ resolution tests
+  readCardHeader, // TASK_2272: exported for quoted-STATUS tests
+  getProjectName, // TASK_2081: exported for regex/quote-stripping tests
+};