kenaz 0.0.0-stage → 0.3.2

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

@@ -0,0 +1,705 @@
+'use strict';
+/**
+ * TASK_1997 R4 — fast-boot banner shows the open-wish count.
+ *
+ * `fetchOpenWishes` hits GET /api/wishes/list?status=pending with a 1 s
+ * timeout; `formatWishesLine` is the pure renderer split out so the three
+ * required banner shapes (count+newest, "0 open", omitted) are testable
+ * without a network round trip.
+ *
+ * ansuz-boot-fast.js only exports these two functions (via a
+ * require.main === module guard around the real boot sequence) — the rest
+ * of main() (lease registration, dashboard project fetch, task-stats scan,
+ * handoff archiving, ...) is out of scope here and already has its own
+ * side-effect surface documented in the file's header comment.
+ *
+ * Run: node --test .specialist/tools/ansuz-boot-fast.test.js
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const http = require('node:http');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const {
+  fetchOpenWishes, formatWishesLine, scanFieldReportCardIds, computeNewFieldReportCount,
+  countOpenNeedsTriageCards, formatFieldReportLine, formatHeimdallTriageLine,
+  countCommitsSinceHeimdallScan, formatHeimdallScanLine,
+  resolveBackendLogPath, readBackendLogTailSync,
+  formatCortexSyncAnomaly, cortexSyncAnomalyLine,
+  readProjectsJsonSync,
+  getProjectName,
+} = require('./ansuz-boot-fast');
+
+async function server(t, handler) {
+  const s = http.createServer(handler);
+  await new Promise((resolve) => s.listen(0, '127.0.0.1', resolve));
+  t.after(() => new Promise((resolve) => { s.closeAllConnections(); s.close(resolve); }));
+  return 'http://127.0.0.1:' + s.address().port;
+}
+
+// ── formatWishesLine (pure) ──────────────────────────────────────────────
+
+test('formatWishesLine renders the count and the newest wish\'s content (<=60 chars)', () => {
+  const wishes = [
+    { id: 'w1', content: 'an older wish', created_at: '2026-09-19T00:00:00Z' },
+    { id: 'w2', content: 'the newest wish content', created_at: '2026-09-21T00:00:00Z' },
+    { id: 'w3', content: 'a middle wish', created_at: '2026-09-20T00:00:00Z' },
+  ];
+  assert.equal(formatWishesLine(wishes), '🪄 Wishes: 3 open (newest: the newest wish content)');
+});
+
+test('formatWishesLine truncates a long newest-content preview to 60 chars with an ellipsis', () => {
+  const long = 'z'.repeat(90);
+  const wishes = [{ id: 'w1', content: long, created_at: '2026-09-21T00:00:00Z' }];
+  const line = formatWishesLine(wishes);
+  assert.equal(line, '🪄 Wishes: 1 open (newest: ' + 'z'.repeat(60) + '…)');
+});
+
+test('formatWishesLine says "0 open" for a successful empty list', () => {
+  assert.equal(formatWishesLine([]), '🪄 Wishes: 0 open');
+});
+
+test('formatWishesLine returns null (banner omits the line) when the fetch failed', () => {
+  assert.equal(formatWishesLine(null), null);
+  assert.equal(formatWishesLine(undefined), null);
+});
+
+test('formatWishesLine tolerates entries missing created_at/content', () => {
+  const wishes = [{ id: 'w1' }, { id: 'w2', content: 'has content, no date' }];
+  const line = formatWishesLine(wishes);
+  assert.match(line, /^🪄 Wishes: 2 open \(newest: /);
+});
+
+// ── fetchOpenWishes (real HTTP against a local test server) ─────────────
+
+test('fetchOpenWishes returns the parsed data array on success', async (t) => {
+  const base = await server(t, (req, res) => {
+    assert.match(req.url, /^\/api\/wishes\/list\?status=pending$/);
+    assert.equal(req.method, 'GET');
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: true, data: [{ id: 'w1', content: 'hi', created_at: '2026-09-21T00:00:00Z' }] }));
+  });
+  const result = await fetchOpenWishes(base, 1000);
+  assert.deepEqual(result, [{ id: 'w1', content: 'hi', created_at: '2026-09-21T00:00:00Z' }]);
+});
+
+test('fetchOpenWishes returns an empty array when the API answers with none', async (t) => {
+  const base = await server(t, (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: true, data: [] }));
+  });
+  const result = await fetchOpenWishes(base, 1000);
+  assert.deepEqual(result, []);
+});
+
+test('fetchOpenWishes returns null when the Dashboard is unreachable (connection refused)', async () => {
+  // Bind a server, read its free port, then close it — guarantees nothing
+  // is listening there when fetchOpenWishes connects.
+  const probe = http.createServer(() => {});
+  await new Promise((resolve) => probe.listen(0, '127.0.0.1', resolve));
+  const deadPort = probe.address().port;
+  await new Promise((resolve) => probe.close(resolve));
+  const result = await fetchOpenWishes('http://127.0.0.1:' + deadPort, 1000);
+  assert.equal(result, null);
+});
+
+test('fetchOpenWishes returns null on timeout', async (t) => {
+  const base = await server(t, () => { /* never respond */ });
+  const started = Date.now();
+  const result = await fetchOpenWishes(base, 50);
+  assert.equal(result, null);
+  assert.ok(Date.now() - started < 2000, 'must not hang past the timeout');
+});
+
+test('fetchOpenWishes returns null on malformed JSON', async (t) => {
+  const base = await server(t, (req, res) => { res.writeHead(200); res.end('not-json'); });
+  const result = await fetchOpenWishes(base, 1000);
+  assert.equal(result, null);
+});
+
+test('fetchOpenWishes returns null when success:false or data is not an array', async (t) => {
+  const base = await server(t, (req, res) => { res.writeHead(200); res.end(JSON.stringify({ success: false, data: [] })); });
+  assert.equal(await fetchOpenWishes(base, 1000), null);
+});
+
+test('fetchOpenWishes returns null on a non-2xx status with a non-JSON body', async (t) => {
+  const base = await server(t, (req, res) => { res.writeHead(500); res.end('server error'); });
+  assert.equal(await fetchOpenWishes(base, 1000), null);
+});
+
+// ── TASK_2063 — pinned call scopes the query to the pinned project ──────
+//
+// resolve_wishes_path() (dashboard/src-tauri routes/wishes.rs) falls back to
+// get_project_root() -- whatever project the Dashboard has currently
+// selected -- when no project_path query param is given. A pinned Ansuz
+// boot (--project-path) must pass its own resolved pin so the wish count/
+// preview belongs to the bound project, not the Dashboard's selection.
+
+test('fetchOpenWishes: pinned call sends project_path=<pin>, URL-encoded', async (t) => {
+  let seenUrl;
+  const base = await server(t, (req, res) => {
+    seenUrl = req.url;
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: true, data: [] }));
+  });
+  await fetchOpenWishes(base, 1000, 'C:/Users/user/Documents/GitHub/Ashfall');
+  assert.equal(seenUrl, '/api/wishes/list?status=pending&project_path=C%3A%2FUsers%2Fuser%2FDocuments%2FGitHub%2FAshfall');
+});
+
+test('fetchOpenWishes: unpinned call (no projectPath arg) sends no project_path', async (t) => {
+  let seenUrl;
+  const base = await server(t, (req, res) => {
+    seenUrl = req.url;
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ success: true, data: [] }));
+  });
+  await fetchOpenWishes(base, 1000);
+  assert.equal(seenUrl, '/api/wishes/list?status=pending');
+});
+
+// ── TASK_2006 R4/R5 — field-report auto-triage boot banner ──────────────
+//
+// scanFieldReportCardIds/computeNewFieldReportCount are the pure halves of
+// fieldReportBannerLine (which itself also touches the watermark file and
+// resolveTasksDir()'s real project path, so it's not unit-tested directly —
+// same split as fetchOpenWishes/formatWishesLine above).
+
+test('computeNewFieldReportCount: first boot (watermark null) establishes a baseline, reports 0 new', () => {
+  const result = computeNewFieldReportCount([2001, 2002, 2003], null);
+  assert.deepEqual(result, { newCount: 0, nextWatermark: 2003 });
+});
+
+test('computeNewFieldReportCount: first boot with no cards yet baselines at 0', () => {
+  assert.deepEqual(computeNewFieldReportCount([], null), { newCount: 0, nextWatermark: 0 });
+});
+
+test('computeNewFieldReportCount: counts only ids strictly newer than the watermark', () => {
+  const result = computeNewFieldReportCount([2001, 2002, 2003, 2004], 2002);
+  assert.deepEqual(result, { newCount: 2, nextWatermark: 2004 });
+});
+
+test('computeNewFieldReportCount: no new ids keeps the watermark unchanged', () => {
+  const result = computeNewFieldReportCount([2001, 2002], 2050);
+  assert.deepEqual(result, { newCount: 0, nextWatermark: 2050 });
+});
+
+function makeTaskYaml({ id, title, tags }) {
+  const tagsLine = 'tags:\n' + tags.map((t) => '  - ' + t).join('\n');
+  return `id: ${id}\ntitle: '${title}'\nstatus: pending\npriority: P2\n${tagsLine}\n`;
+}
+
+test('scanFieldReportCardIds finds field-report-tagged cards across backlog/active, ignores others', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-field-report-scan-'));
+  try {
+    fs.mkdirSync(path.join(dir, 'backlog'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'active'), { recursive: true });
+    fs.writeFileSync(
+      path.join(dir, 'backlog', 'TASK_2100_dashboard_crash.yaml'),
+      makeTaskYaml({ id: 'TASK_2100', title: '[field-report:bug] dashboard crash', tags: ['field-report', 'bug'] }),
+    );
+    fs.writeFileSync(
+      path.join(dir, 'active', 'TASK_2101_add_dark_mode.yaml'),
+      makeTaskYaml({ id: 'TASK_2101', title: '[field-report:feature] add dark mode', tags: ['field-report', 'feature'] }),
+    );
+    // Not a field-report card -- must be excluded.
+    fs.writeFileSync(
+      path.join(dir, 'backlog', 'TASK_9999_unrelated.yaml'),
+      makeTaskYaml({ id: 'TASK_9999', title: 'unrelated task', tags: ['code'] }),
+    );
+    const ids = scanFieldReportCardIds(dir).sort((a, b) => a - b);
+    assert.deepEqual(ids, [2100, 2101]);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('scanFieldReportCardIds returns an empty array for a tasks dir with no field-report cards', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-field-report-scan-empty-'));
+  try {
+    assert.deepEqual(scanFieldReportCardIds(dir), []);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── TASK_2040 — needs-triage count on the field-report banner line ──────
+
+// ── TASK_2245 — Heimdall needs-triage boot line ──────────────────────────
+
+test('formatHeimdallTriageLine: omitted at 0, one line with the count when > 0', () => {
+  assert.equal(formatHeimdallTriageLine(0), null);
+  assert.match(formatHeimdallTriageLine(4), /Heimdall: 4 finding\(s\) awaiting triage/);
+});
+
+test('countOpenNeedsTriageCards splits heimdall cards from field-report cards', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-heimdall-triage-'));
+  try {
+    fs.mkdirSync(path.join(dir, 'backlog'), { recursive: true });
+    fs.writeFileSync(path.join(dir, 'backlog', 'TASK_1_h.yaml'),
+      makeTaskYaml({ id: 'TASK_1', title: 'split god file', tags: ['heimdall', 'needs-triage'] }));
+    fs.writeFileSync(path.join(dir, 'backlog', 'TASK_2_f.yaml'),
+      makeTaskYaml({ id: 'TASK_2', title: '[field-report:bug] x', tags: ['field-report', 'needs-triage'] }));
+    assert.equal(countOpenNeedsTriageCards(dir, { heimdall: true }), 1);
+    assert.equal(countOpenNeedsTriageCards(dir), 1);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('formatFieldReportLine: omitted (null) when both counts are 0', () => {
+  assert.equal(formatFieldReportLine(0, 0), null);
+});
+
+test('formatFieldReportLine: shows only the "new cards" segment when needs-triage is 0', () => {
+  assert.equal(formatFieldReportLine(3, 0), '📥 Field reports: 3 new card(s) since last boot');
+});
+
+test('formatFieldReportLine: shows only the needs-triage segment when new-card count is 0', () => {
+  assert.equal(formatFieldReportLine(0, 2), '📥 Field reports: 2 needing triage');
+});
+
+test('formatFieldReportLine: shows both segments when both counts are > 0', () => {
+  assert.equal(
+    formatFieldReportLine(3, 2),
+    '📥 Field reports: 3 new card(s) since last boot, 2 needing triage',
+  );
+});
+
+test('countOpenNeedsTriageCards counts needs-triage-tagged cards across backlog/active/blocked, ignores done/cancel and untagged', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-needs-triage-scan-'));
+  try {
+    for (const st of ['backlog', 'active', 'blocked', 'done', 'cancel']) {
+      fs.mkdirSync(path.join(dir, st), { recursive: true });
+    }
+    fs.writeFileSync(
+      path.join(dir, 'backlog', 'TASK_3001_scope_project.yaml'),
+      makeTaskYaml({ id: 'TASK_3001', title: '[field-report:bug] scoped wish', tags: ['field-report', 'needs-triage'] }),
+    );
+    fs.writeFileSync(
+      path.join(dir, 'active', 'TASK_3002_feature_proposal.yaml'),
+      makeTaskYaml({ id: 'TASK_3002', title: '[field-report:feature] proposal', tags: ['field-report', 'needs-triage'] }),
+    );
+    fs.writeFileSync(
+      path.join(dir, 'blocked', 'TASK_3003_blocked_triage.yaml'),
+      makeTaskYaml({ id: 'TASK_3003', title: '[field-report:bug] blocked triage', tags: ['field-report', 'needs-triage'] }),
+    );
+    // Already triaged (done/cancel) -- must NOT be counted, even though still tagged.
+    fs.writeFileSync(
+      path.join(dir, 'done', 'TASK_3004_already_triaged.yaml'),
+      makeTaskYaml({ id: 'TASK_3004', title: '[field-report:bug] already triaged', tags: ['field-report', 'needs-triage'] }),
+    );
+    fs.writeFileSync(
+      path.join(dir, 'cancel', 'TASK_3005_declined.yaml'),
+      makeTaskYaml({ id: 'TASK_3005', title: '[field-report:bug] declined', tags: ['field-report', 'needs-triage'] }),
+    );
+    // Open but not tagged needs-triage -- must NOT be counted.
+    fs.writeFileSync(
+      path.join(dir, 'backlog', 'TASK_9999_unrelated.yaml'),
+      makeTaskYaml({ id: 'TASK_9999', title: 'unrelated task', tags: ['code'] }),
+    );
+    assert.equal(countOpenNeedsTriageCards(dir), 3);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('countOpenNeedsTriageCards returns 0 for a tasks dir with no needs-triage cards', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-needs-triage-scan-empty-'));
+  try {
+    assert.equal(countOpenNeedsTriageCards(dir), 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── TASK_2044 — dead Cortex DB surfaced loudly ──────────────────────────
+// Fixture: backend.log WARN lines for a Cortex DB that will not open.
+
+// ── getProjectName (TASK_2081: \s* regex fix + quote stripping) ─────────────
+
+function writeProjectYaml(dir, nameLine) {
+  fs.mkdirSync(path.join(dir, '.kenaz'), { recursive: true });
+  fs.writeFileSync(path.join(dir, '.kenaz', 'project.yaml'), nameLine + '\n');
+}
+
+test('getProjectName: "name: Ashfall" -> Ashfall', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-project-name-'));
+  try {
+    writeProjectYaml(dir, 'name: Ashfall');
+    assert.equal(getProjectName(dir), 'Ashfall');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('getProjectName: "name:sonic" (no space) -> sonic', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-project-name-nospace-'));
+  try {
+    writeProjectYaml(dir, 'name:sonic');
+    assert.equal(getProjectName(dir), 'sonic');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('getProjectName: \'name: "Ashfall"\' (double-quoted) -> Ashfall, no quotes', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-project-name-dquote-'));
+  try {
+    writeProjectYaml(dir, 'name: "Ashfall"');
+    assert.equal(getProjectName(dir), 'Ashfall');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("getProjectName: \"name: 'Ashfall'\" (single-quoted) -> Ashfall, no quotes", () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-project-name-squote-'));
+  try {
+    writeProjectYaml(dir, "name: 'Ashfall'");
+    assert.equal(getProjectName(dir), 'Ashfall');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('getProjectName: no name line in project.yaml -> falls back to path.basename', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-project-name-nomatch-'));
+  try {
+    writeProjectYaml(dir, 'core_path: /some/where');
+    assert.equal(getProjectName(dir), path.basename(dir));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('getProjectName: \'name: ""\' (empty after stripping quotes) -> falls back to path.basename', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-project-name-empty-'));
+  try {
+    writeProjectYaml(dir, 'name: ""');
+    assert.equal(getProjectName(dir), path.basename(dir));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('getProjectName: missing project.yaml -> falls back to path.basename', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-project-name-missing-'));
+  try {
+    assert.equal(getProjectName(dir), path.basename(dir));
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// Negative control (A2): the OLD regex /^name:s*(.+)$/ (missing backslash,
+// matching the literal letter "s" not whitespace) must FAIL the no-space
+// case above -- proving the fixed regex is actually exercised, not just
+// coincidentally passing because (.+) is permissive.
+test('getProjectName negative control: the old buggy regex mis-parses "name:sonic"', () => {
+  const raw = 'name:sonic\n';
+  const oldRegex = /^name:s*(.+)$/m; // pre-TASK_2081 regex, deliberately reproduced
+  const m = raw.match(oldRegex);
+  assert.ok(m, 'old regex should still match something (that is the bug)');
+  assert.notEqual(m[1].trim(), 'sonic');
+  assert.equal(m[1].trim(), 'onic'); // literal "s" consumed the leading "s" of "sonic"
+});
+
+// ── formatCortexSyncAnomaly / readBackendLogTailSync / resolveBackendLogPath ──
+
+test('formatCortexSyncAnomaly: most recent Cortex auto-sync line is a DB open failure -> line names path + count', () => {
+  const tail = [
+    '2026-09-03T00:00:00.000000Z  WARN Cortex auto-sync failed: DB open failed (C:\\Users\\user\\.kenaz\\cortex\\meta_graph\\graph): invalid unordered_map<K, T> key',
+    '2026-09-04T00:00:00.000000Z  INFO Cortex: synced memory for project Kenaz',
+    '2026-09-26T06:26:58.103504Z  WARN Cortex auto-sync failed: DB open failed (C:\\Users\\user\\.kenaz\\cortex\\meta_graph\\graph): invalid unordered_map<K, T> key',
+  ].join('\n');
+  const line = formatCortexSyncAnomaly(tail);
+  assert.match(line, /^⚠️ ANOMALY: CORTEX_SYNC_ERROR — DB open failed: C:\\Users\\user\\.kenaz\\cortex\\meta_graph\\graph \(2 failure\(s\) in backend\.log tail\)/);
+});
+
+test('formatCortexSyncAnomaly: a later success line clears the anomaly', () => {
+  const tail = [
+    '2026-09-26T06:26:58.103504Z  WARN Cortex auto-sync failed: DB open failed (C:\\x\\graph): invalid unordered_map<K, T> key',
+    '2026-09-26T07:16:52.042326Z  INFO Cortex auto-sync completed',
+  ].join('\n');
+  assert.equal(formatCortexSyncAnomaly(tail), null);
+});
+
+test('formatCortexSyncAnomaly: no Cortex auto-sync lines in tail -> null', () => {
+  assert.equal(formatCortexSyncAnomaly('some unrelated log line\nanother one\n'), null);
+  assert.equal(formatCortexSyncAnomaly(''), null);
+  assert.equal(formatCortexSyncAnomaly(null), null);
+});
+
+// Ansuz review fix (post-6d34559c1): non-terminal "Cortex auto-sync" lines
+// (trigger / already-in-progress / skipped) must NOT be treated as clearing
+// a prior failure -- only completed/failed:/task panicked: are terminal.
+
+test('formatCortexSyncAnomaly: a failure followed by a trigger line still shows the anomaly', () => {
+  const tail = [
+    '2026-09-26T06:26:58Z  WARN Cortex auto-sync failed: DB open failed (C:\\x\\graph): invalid unordered_map<K, T> key',
+    '2026-09-26T07:00:00Z  INFO Triggering Cortex auto-sync for C:\\project',
+  ].join('\n');
+  assert.match(formatCortexSyncAnomaly(tail), /CORTEX_SYNC_ERROR/);
+});
+
+test('formatCortexSyncAnomaly: a failure followed by "already in progress, skipping" still shows the anomaly', () => {
+  const tail = [
+    '2026-09-26T06:26:58Z  WARN Cortex auto-sync failed: DB open failed (C:\\x\\graph): invalid unordered_map<K, T> key',
+    '2026-09-26T07:00:01Z  INFO Cortex auto-sync already in progress, skipping',
+  ].join('\n');
+  assert.match(formatCortexSyncAnomaly(tail), /CORTEX_SYNC_ERROR/);
+});
+
+test('formatCortexSyncAnomaly: a failure followed by "skipped: no tokio runtime" still shows the anomaly', () => {
+  const tail = [
+    '2026-09-26T06:26:58Z  WARN Cortex auto-sync failed: DB open failed (C:\\x\\graph): invalid unordered_map<K, T> key',
+    '2026-09-26T07:00:02Z  WARN Cortex auto-sync skipped: no tokio runtime on this thread',
+  ].join('\n');
+  assert.match(formatCortexSyncAnomaly(tail), /CORTEX_SYNC_ERROR/);
+});
+
+test('formatCortexSyncAnomaly: failure then a real terminal "completed" line clears it', () => {
+  const tail = [
+    '2026-09-26T06:26:58Z  WARN Cortex auto-sync failed: DB open failed (C:\\x\\graph): invalid unordered_map<K, T> key',
+    '2026-09-26T07:00:00Z  INFO Triggering Cortex auto-sync for C:\\project',
+    '2026-09-26T07:00:03Z  INFO Cortex auto-sync completed',
+  ].join('\n');
+  assert.equal(formatCortexSyncAnomaly(tail), null);
+});
+
+test('formatCortexSyncAnomaly: most recent terminal line is "task panicked" -> shown (not a DB-open match, but exercises the terminal-line filter)', () => {
+  const tail = [
+    '2026-09-26T07:00:00Z  INFO Cortex auto-sync completed',
+    '2026-09-26T07:05:00Z  WARN Cortex auto-sync task panicked: DB open failed (C:\\x\\graph): invalid unordered_map<K, T> key',
+  ].join('\n');
+  assert.match(formatCortexSyncAnomaly(tail), /CORTEX_SYNC_ERROR/);
+});
+
+test('readBackendLogTailSync: reads only the last N bytes of a fixture file', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-backend-log-tail-'));
+  const file = path.join(dir, 'backend.log');
+  try {
+    const filler = 'x'.repeat(1000) + '\n';
+    const wanted = 'WARN Cortex auto-sync failed: DB open failed (x): boom\n';
+    fs.writeFileSync(file, filler + wanted);
+    const tail = readBackendLogTailSync(file, 100);
+    assert.ok(tail.length <= 100);
+    assert.match(tail, /Cortex auto-sync failed/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('readBackendLogTailSync: missing file -> null, no throw', () => {
+  assert.doesNotThrow(() => {
+    assert.equal(readBackendLogTailSync(path.join(os.tmpdir(), 'kenaz-nonexistent-' + Date.now() + '.log'), 1000), null);
+  });
+});
+
+test('cortexSyncAnomalyLine: fixture path override with a recent failure -> line', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-cortex-log-fixture-'));
+  const file = path.join(dir, 'backend.log');
+  try {
+    fs.writeFileSync(file, '2026-09-26T06:26:58Z  WARN Cortex auto-sync failed: DB open failed (C:\\x\\graph): invalid unordered_map<K, T> key\n');
+    assert.match(cortexSyncAnomalyLine(file), /CORTEX_SYNC_ERROR/);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('cortexSyncAnomalyLine: fixture path override, healthy (most recent line is success) -> null', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-cortex-log-fixture-healthy-'));
+  const file = path.join(dir, 'backend.log');
+  try {
+    fs.writeFileSync(file, '2026-09-26T07:16:52Z  INFO Cortex auto-sync completed\n');
+    assert.equal(cortexSyncAnomalyLine(file), null);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('cortexSyncAnomalyLine: missing fixture file -> null, no throw', () => {
+  assert.doesNotThrow(() => {
+    assert.equal(cortexSyncAnomalyLine(path.join(os.tmpdir(), 'kenaz-nonexistent-cortex-' + Date.now() + '.log')), null);
+  });
+});
+
+test('resolveBackendLogPath: never throws and, when resolvable, returns a "Kenaz Dashboard/backend.log" path', () => {
+  let result;
+  assert.doesNotThrow(() => { result = resolveBackendLogPath(); });
+  if (result !== null) {
+    assert.ok(result.includes('Kenaz Dashboard'));
+    assert.ok(result.endsWith('backend.log'));
+  }
+});
+
+test('resolveBackendLogPath: on win32 with LOCALAPPDATA set, resolves under it', () => {
+  const origPlatform = process.platform;
+  const origEnv = process.env.LOCALAPPDATA;
+  try {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    process.env.LOCALAPPDATA = 'C:\\Users\\user\\AppData\\Local';
+    const p = resolveBackendLogPath();
+    assert.equal(p, path.join('C:\\Users\\user\\AppData\\Local', 'Kenaz Dashboard', 'backend.log'));
+  } finally {
+    Object.defineProperty(process, 'platform', { value: origPlatform });
+    if (origEnv === undefined) delete process.env.LOCALAPPDATA; else process.env.LOCALAPPDATA = origEnv;
+  }
+});
+
+test('resolveBackendLogPath: on win32 with LOCALAPPDATA unset -> null (skip, never throw)', () => {
+  const origPlatform = process.platform;
+  const origEnv = process.env.LOCALAPPDATA;
+  try {
+    Object.defineProperty(process, 'platform', { value: 'win32' });
+    delete process.env.LOCALAPPDATA;
+    assert.equal(resolveBackendLogPath(), null);
+  } finally {
+    Object.defineProperty(process, 'platform', { value: origPlatform });
+    if (origEnv === undefined) delete process.env.LOCALAPPDATA; else process.env.LOCALAPPDATA = origEnv;
+  }
+});
+
+// ── TASK_2057 — readProjectsJsonSync resolves __kenaz_core__ ────────────
+//
+// dev/PROJECT_REGISTRY_DUPLICATE_ASSESSMENT.md: the core entry's `path` in
+// ~/.kenaz/projects.json is the literal token "__kenaz_core__", not a real
+// path. readProjectsJsonSync used to return that token verbatim; it now
+// resolves through core-resolve.js's shared resolveVirtualPath (KENAZ_SOURCE_DIR,
+// else the core dir auto-discovered from core-resolve.js's own location).
+// os.homedir() reads HOME/USERPROFILE at call time, so overriding them here
+// points readProjectsJsonSync at a fixture registry without touching the
+// real ~/.kenaz/projects.json.
+
+function withEnv(vars, fn) {
+  const saved = {};
+  for (const k of Object.keys(vars)) saved[k] = process.env[k];
+  for (const k of Object.keys(vars)) {
+    if (vars[k] === null) delete process.env[k]; else process.env[k] = vars[k];
+  }
+  try {
+    return fn();
+  } finally {
+    for (const k of Object.keys(saved)) {
+      if (saved[k] === undefined) delete process.env[k]; else process.env[k] = saved[k];
+    }
+  }
+}
+
+function writeFixtureRegistry(homeDir, projectPath) {
+  fs.mkdirSync(path.join(homeDir, '.kenaz'), { recursive: true });
+  fs.writeFileSync(
+    path.join(homeDir, '.kenaz', 'projects.json'),
+    JSON.stringify({
+      currentProjectId: 'default',
+      projects: [{ id: 'default', name: 'Kenaz', path: projectPath, is_core: true }],
+    }),
+  );
+}
+
+test('readProjectsJsonSync resolves __kenaz_core__ via KENAZ_SOURCE_DIR', () => {
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-projects-json-'));
+  try {
+    writeFixtureRegistry(homeDir, '__kenaz_core__');
+    const result = withEnv(
+      { HOME: homeDir, USERPROFILE: homeDir, KENAZ_SOURCE_DIR: 'C:\\Users\\user\\Documents\\GitHub\\KenazAI' },
+      () => readProjectsJsonSync(),
+    );
+    assert.deepEqual(result, {
+      currentProjectPath: 'C:/Users/user/Documents/GitHub/KenazAI',
+      currentProjectName: 'Kenaz',
+    });
+  } finally {
+    fs.rmSync(homeDir, { recursive: true, force: true });
+  }
+});
+
+test('readProjectsJsonSync resolves __kenaz_core__ via auto-discovered core dir when KENAZ_SOURCE_DIR is unset', () => {
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-projects-json-autodisc-'));
+  try {
+    writeFixtureRegistry(homeDir, '__kenaz_core__');
+    const result = withEnv(
+      { HOME: homeDir, USERPROFILE: homeDir, KENAZ_SOURCE_DIR: null },
+      () => readProjectsJsonSync(),
+    );
+    assert.ok(result, 'must still resolve (not null) via the __dirname-relative fallback');
+    assert.notEqual(result.currentProjectPath, '__kenaz_core__', 'must not leak the literal token');
+    assert.ok(
+      fs.existsSync(path.join(result.currentProjectPath, '.specialist')),
+      'auto-discovered core dir must be a real KenazAI checkout (has .specialist/)',
+    );
+  } finally {
+    fs.rmSync(homeDir, { recursive: true, force: true });
+  }
+});
+
+test('readProjectsJsonSync leaves a non-token path unchanged', () => {
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-projects-json-plain-'));
+  try {
+    writeFixtureRegistry(homeDir, 'C:/Users/user/Documents/GitHub/some-sub-project');
+    const result = withEnv(
+      { HOME: homeDir, USERPROFILE: homeDir, KENAZ_SOURCE_DIR: 'C:\\Users\\user\\Documents\\GitHub\\KenazAI' },
+      () => readProjectsJsonSync(),
+    );
+    assert.equal(result.currentProjectPath, 'C:/Users/user/Documents/GitHub/some-sub-project');
+  } finally {
+    fs.rmSync(homeDir, { recursive: true, force: true });
+  }
+});
+
+test('readProjectsJsonSync returns null when currentProjectId has no matching entry', () => {
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-projects-json-nomatch-'));
+  try {
+    fs.mkdirSync(path.join(homeDir, '.kenaz'), { recursive: true });
+    fs.writeFileSync(
+      path.join(homeDir, '.kenaz', 'projects.json'),
+      JSON.stringify({ currentProjectId: 'missing', projects: [] }),
+    );
+    const result = withEnv({ HOME: homeDir, USERPROFILE: homeDir }, () => readProjectsJsonSync());
+    assert.equal(result, null);
+  } finally {
+    fs.rmSync(homeDir, { recursive: true, force: true });
+  }
+});
+
+test('readProjectsJsonSync returns null when ~/.kenaz/projects.json does not exist', () => {
+  const homeDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-projects-json-missing-'));
+  try {
+    const result = withEnv({ HOME: homeDir, USERPROFILE: homeDir }, () => readProjectsJsonSync());
+    assert.equal(result, null);
+  } finally {
+    fs.rmSync(homeDir, { recursive: true, force: true });
+  }
+});
+
+// Peer report 2026-10-05 (wei@Ashfall): inside Bifrost Codex the banner's
+// conversation_id came from Claude hook hints, not the Codex session, so peer
+// replies bound to it were lost. The harness's own id must win.
+test('harnessSessionIdFromEnv returns the Codex session id when exported', () => {
+  const { harnessSessionIdFromEnv } = require('./ansuz-boot-fast.js');
+  assert.equal(harnessSessionIdFromEnv({ CODEX_SESSION_ID: '01a1079e-3436-7060-b767-641527336f52' }), '01a1079e-3436-7060-b767-641527336f52');
+  assert.equal(harnessSessionIdFromEnv({ CODEX_SESSION_ID: '  ' }), null);
+  assert.equal(harnessSessionIdFromEnv({}), null, 'Claude sessions keep the hint chain');
+  assert.equal(harnessSessionIdFromEnv(undefined), null);
+});
+
+// -- TASK_2363: commits since last Heimdall scan --
+
+test('countCommitsSinceHeimdallScan counts records newer than the last scan', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-test-heimdall-scan-'));
+  try {
+    const sp = path.join(dir, '.kenaz', 'specialist');
+    fs.mkdirSync(sp, { recursive: true });
+    assert.equal(countCommitsSinceHeimdallScan(dir), 0, 'no record file');
+    fs.writeFileSync(path.join(sp, 'heimdall_commits.jsonl'),
+      '{"sha":"a","at":100}\n{"sha":"b","at":200}\ntorn{\n{"sha":"c","at":300}\n');
+    assert.equal(countCommitsSinceHeimdallScan(dir), 3, 'no scan yet: all records');
+    fs.writeFileSync(path.join(sp, 'heimdall_last_scan.json'), '{"at":200}');
+    assert.equal(countCommitsSinceHeimdallScan(dir), 1);
+    assert.match(formatHeimdallScanLine(1), /1 commits since last Heimdall scan/);
+    assert.equal(formatHeimdallScanLine(0), null);
+  } finally { fs.rmSync(dir, { recursive: true, force: true }); }
+});