kenaz 0.3.9 → 0.3.11

package/core/.formation/tools/kenaz-stats.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * `kenaz stats [--days N] [--json]` (TASK_2408): is Kenaz worth it? Read-only, no Dashboard needed.
+ * Four sections, each number names its source; a missing source says "no data", never 0.
+ *   1. peer delivery   <project>/.kenaz/peer/inbox.sqlite (peer_messages, direction='in'), projects from ~/.kenaz/projects.json
+ *   2. dispatch        git history of the project: `Merge TASK_n` commits vs `[TASK_n]` commits (first-pass = one merge, no later fix-up on the main line)
+ *   3. field reports   ~/.kenaz/cortex/field_reports.db (card_id) -> the card's merge commit -> first release tag containing it
+ *   4. alaya           ~/.kenaz/cortex/global_memory.db (alaya_bijas, alaya_exported, seed_imports)
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const DAY = 86400000;
+const NO_DATA = 'no data';
+
+function openDb(file) {
+  if (!fs.existsSync(file)) return { err: `${NO_DATA} (${file} not found)` };
+  try {
+    const { DatabaseSync } = require('node:sqlite');
+    return { db: new DatabaseSync(file, { readOnly: true }) };
+  } catch (e) { return { err: `${NO_DATA} (cannot read ${file}: ${['MODULE_NOT_FOUND', 'ERR_UNKNOWN_BUILTIN_MODULE'].includes(e.code) ? 'needs Node >= 22.5 for node:sqlite' : e.message})` }; }
+}
+function rows(db, sql, ...args) { try { return db.prepare(sql).all(...args); } catch (_) { return null; } }
+
+const ms = (s) => { const t = Date.parse(s); return Number.isNaN(t) ? null : t; };
+function pct(sorted, q) { return sorted.length ? sorted[Math.min(sorted.length - 1, Math.ceil(q * sorted.length) - 1)] : null; }
+function dur(msec) {
+  if (msec == null) return NO_DATA;
+  const s = msec / 1000;
+  if (s < 90) return `${Math.round(s)}s`;
+  if (s < 5400) return `${Math.round(s / 60)}m`;
+  if (s < 129600) return `${(s / 3600).toFixed(1)}h`;
+  return `${(s / 86400).toFixed(1)}d`;
+}
+
+/** Project roots whose peer inbox to read: registered projects (real paths only) plus cwd. */
+function projectRoots(home, cwd) {
+  const out = new Set([path.resolve(cwd)]);
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(home, '.kenaz', 'projects.json'), 'utf8'));
+    for (const p of j.projects || []) if (p.path && !p.path.startsWith('__') && fs.existsSync(p.path)) out.add(path.resolve(p.path));
+  } catch (_) { /* no registry: cwd only */ }
+  return [...out];
+}
+
+function peerStats({ roots, now, days }) {
+  const since = now - days * DAY;
+  const src = '<project>/.kenaz/peer/inbox.sqlite peer_messages (direction=in)';
+  const msgs = [];
+  const missing = [];
+  for (const root of roots) {
+    const o = openDb(path.join(root, '.kenaz', 'peer', 'inbox.sqlite'));
+    if (!o.db) { missing.push(root); continue; }
+    const r = rows(o.db, "SELECT created_at, delivered_to_session d, delivered_at, pushed_at, delivery_state FROM peer_messages WHERE direction='in'");
+    o.db.close();
+    for (const m of r || []) if ((ms(m.created_at) || 0) >= since) msgs.push(m);
+  }
+  if (!msgs.length) return { source: src, note: `${NO_DATA} (no inbound messages in ${days}d across ${roots.length - missing.length} inbox(es))` };
+  const delivered = msgs.filter((m) => m.d === 1);
+  const push = delivered.filter((m) => m.pushed_at).length;
+  const lat = delivered.map((m) => ms(m.delivered_at) - ms(m.created_at)).filter((x) => x >= 0).sort((a, b) => a - b);
+  const reasons = {};
+  for (const m of msgs) if (m.delivery_state && m.delivery_state !== 'delivered') reasons[m.delivery_state] = (reasons[m.delivery_state] || 0) + 1;
+  return {
+    source: src, received: msgs.length, delivered: delivered.length, byPush: push, byPull: delivered.length - push,
+    pending: msgs.length - delivered.length, deliveredRate: delivered.length / msgs.length,
+    medianMs: pct(lat, 0.5), p90Ms: pct(lat, 0.9), undeliverableReasons: reasons,
+    note: 'delivery log (peer_delivery_log.rs) is in-memory only, so reasons come from peer_messages.delivery_state',
+  };
+}
+
+function git(cwd, ...args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 64 << 20 });
+}
+/** Commits of the repo (all refs): [{sha, parents, t, subject, firstParent, onHead}] newest first; null when not a git repo. */
+function readCommits(repo, sinceMs) {
+  try {
+    const fmt = '%H%x09%P%x09%ct%x09%s';
+    const head = new Set(git(repo, 'rev-list', 'HEAD').split('\n').filter(Boolean));
+    const first = new Set(git(repo, 'log', '--first-parent', '--format=%H').split('\n').filter(Boolean));
+    return git(repo, 'log', '--all', `--since=${new Date(sinceMs).toISOString()}`, `--format=${fmt}`).split('\n').filter(Boolean).map((l) => {
+      const [sha, parents, ct, ...s] = l.split('\t');
+      return { sha, parents: parents.split(' ').filter(Boolean), t: Number(ct) * 1000, subject: s.join('\t'), firstParent: first.has(sha), onHead: head.has(sha) };
+    });
+  } catch (_) { return null; }
+}
+
+/** Commits the merged branch gained after the agent's first `task completed` commit (fixes before the merge). */
+function branchFixups(repo, merges) {
+  let n = 0;
+  for (const m of merges) {
+    if (m.parents.length < 2) continue;
+    try {
+      const subj = git(repo, 'log', '--reverse', '--format=%s', `${m.parents[0]}..${m.parents[1]}`).split('\n').filter(Boolean);
+      const first = subj.findIndex((s) => /task completed\s*$/i.test(s));
+      // the agent's own follow-ups reuse the `task completed` subject; anything else was added after delivery
+      if (first >= 0) n += subj.slice(first + 1).filter((s) => !/task completed\s*$/i.test(s)).length;
+    } catch (_) { /* unreadable merge: not judged */ }
+  }
+  return n;
+}
+
+function dispatchStats({ repo, now, days }) {
+  const src = 'git log of ' + repo + ' (`Merge TASK_n` commits, `[TASK_n]` commits)';
+  const commits = readCommits(repo, now - days * DAY);
+  if (!commits) return { source: src, note: `${NO_DATA} (not a git repository)` };
+  const cards = new Map(); // n -> {merges:[commit], work:number, fixups:[]}
+  const card = (n) => { if (!cards.has(n)) cards.set(n, { merges: [], work: [], fixups: [] }); return cards.get(n); };
+  for (const c of commits) {
+    const m = /^Merge TASK_(\d+)/i.exec(c.subject);
+    if (m) { card(m[1]).merges.push(c); continue; }
+    const w = /^\[TASK_(\d+)\]/i.exec(c.subject);
+    if (w) { card(w[1]).work.push(c); if (c.firstParent && c.parents.length < 2) card(w[1]).fixups.push(c); }
+  }
+  if (!cards.size) return { source: src, note: `${NO_DATA} (no TASK commits in ${days}d)` };
+  const merged = []; const rework = []; const unmerged = []; const noMergeCommit = [];
+  for (const [n, c] of cards) {
+    const landed = c.merges.some((x) => x.onHead) || c.work.some((x) => x.onHead);
+    if (!landed) { unmerged.push(`TASK_${n}`); continue; }
+    if (!c.merges.length) { noMergeCommit.push(`TASK_${n}`); continue; }
+    merged.push(`TASK_${n}`);
+    const firstMerge = Math.min(...c.merges.map((x) => x.t));
+    const after = c.fixups.filter((x) => x.t >= firstMerge);
+    const abandoned = c.work.filter((x) => /task completed\s*$/i.test(x.subject) && !x.onHead).length;
+    const fixedOnBranch = branchFixups(repo, c.merges);
+    if (c.merges.length > 1) rework.push({ card: `TASK_${n}`, why: `re-dispatched/merged ${c.merges.length} times` });
+    else if (abandoned) rework.push({ card: `TASK_${n}`, why: `${abandoned} agent delivery commit(s) never merged (re-dispatch or a losing A/B arm)` });
+    else if (fixedOnBranch) rework.push({ card: `TASK_${n}`, why: `${fixedOnBranch} commit(s) on the branch after the agent's delivery, before the merge` });
+    else if (after.length) rework.push({ card: `TASK_${n}`, why: `${after.length} fix-up commit(s) on the main line after the merge` });
+  }
+  return {
+    source: src, dispatched: cards.size, merged: merged.length, landedWithoutMergeCommit: noMergeCommit.length, notMerged: unmerged.length, firstPass: merged.length - rework.length,
+    firstPassRate: merged.length ? (merged.length - rework.length) / merged.length : null, rework, notMergedCards: unmerged.slice(0, 20),
+    note: 'dispatched = cards with any [TASK_n] or Merge TASK_n commit in the window; first-pass rate = cards with a Merge TASK_n commit on HEAD, merged once, no main-line fix-up; cards landed without a merge commit (fast-forward) are not judged; not merged = commits not reachable from HEAD (first 20 listed)',
+  };
+}
+
+function fieldStats({ home, repo, now, days }) {
+  const f = path.join(home, '.kenaz', 'cortex', 'field_reports.db');
+  const src = f + ' field_reports + git tags of ' + repo;
+  const o = openDb(f);
+  if (!o.db) return { source: src, note: o.err };
+  const all = rows(o.db, 'SELECT id, card_id, received_at, kind FROM field_reports WHERE quarantined = 0') || [];
+  o.db.close();
+  const reps = all.filter((r) => (ms(r.received_at) || 0) >= now - days * DAY);
+  if (!reps.length) return { source: src, note: `${NO_DATA} (no field reports in ${days}d)` };
+  let tags = null;
+  const mergeOf = {};
+  try {
+    tags = git(repo, 'for-each-ref', '--sort=creatordate', '--format=%(refname:short)\t%(creatordate:unix)', 'refs/tags/v*').split('\n').filter(Boolean).map((l) => { const [t, u] = l.split('\t'); return { tag: t, t: Number(u) * 1000 }; });
+    // closing commit of a card = newest commit on HEAD whose subject names it (Merge TASK_n, [TASK_n] or (TASK_n))
+    for (const l of git(repo, 'log', 'HEAD', '--format=%H\t%s').split('\n')) {
+      const [sha, ...sub] = l.split('\t');
+      for (const m of sub.join('\t').matchAll(/\bTASK_\d+\b/gi)) if (!mergeOf[m[0].toUpperCase()]) mergeOf[m[0].toUpperCase()] = sha;
+    }
+  } catch (_) { /* tags stay null */ }
+  // A card closed without a commit naming it (duplicate, moot, fixed under another card) is closed, not open.
+  const cardStatus = {};
+  for (const st of ['backlog', 'active', 'blocked', 'done', 'cancel', 'archived']) {
+    try { for (const f of fs.readdirSync(path.join(repo, '.kenaz', 'tasks', st))) { const m = /^(TASK_\d+)_/i.exec(f); if (m) cardStatus[m[1].toUpperCase()] = st; } } catch (_) { /* no tasks dir */ }
+  }
+  const released = []; const open = []; const closed = []; const noCard = [];
+  for (const r of reps) {
+    const recv = ms(r.received_at);
+    if (!r.card_id) { noCard.push(r.id); continue; }
+    const id = String(r.card_id).toUpperCase();
+    const sha = mergeOf[id];
+    let tag = null;
+    if (sha && tags) {
+      try { const have = new Set(git(repo, 'tag', '--contains', sha).split('\n').filter(Boolean)); tag = tags.find((t) => have.has(t.tag)) || null; } catch (_) { /* open */ }
+    }
+    const st = cardStatus[id];
+    if (tag) released.push({ id: r.id, card: r.card_id, tag: tag.tag, latencyMs: tag.t - recv });
+    else if (['done', 'cancel', 'archived'].includes(st)) closed.push({ id: r.id, card: r.card_id, status: st });
+    else open.push({ id: r.id, card: r.card_id, ageMs: now - recv, status: (sha ? 'landed, not in a release tag' : 'no commit names this card') + (st ? `; card ${st}` : '; card not found') });
+  }
+  const lat = released.map((x) => x.latencyMs).sort((a, b) => a - b);
+  return { source: src, reports: reps.length, released: released.length, medianMs: pct(lat, 0.5), releasedList: released, open, closedWithoutRelease: closed.length, closedByStatus: closed.reduce((a, c) => ({ ...a, [c.status]: (a[c.status] || 0) + 1 }), {}), withoutCard: noCard.length, note: tags ? undefined : `${NO_DATA} for release tags (not a git repository)` };
+}
+
+function alayaStats({ home, now, days }) {
+  const f = path.join(home, '.kenaz', 'cortex', 'global_memory.db');
+  const o = openDb(f);
+  if (!o.db) return { source: f, note: o.err };
+  const since = new Date(now - days * DAY).toISOString().slice(0, 19).replace('T', ' ');
+  const one = (sql, ...a) => { const r = rows(o.db, sql, ...a); return r && r[0] ? r[0] : null; };
+  const b = one('SELECT count(*) n, sum(activated_count > 0) active, coalesce(sum(activated_count),0) acts FROM alaya_bijas');
+  const origin = rows(o.db, 'SELECT origin, count(*) n FROM alaya_bijas GROUP BY origin');
+  const fresh = one('SELECT count(*) n FROM alaya_bijas WHERE synced_at >= ?', since);
+  const exp = one('SELECT count(*) n, sum(exported_at >= ?) w FROM alaya_exported', since);
+  const seeds = one('SELECT count(*) n FROM seed_imports WHERE imported_at >= ?', since);
+  o.db.close();
+  return {
+    source: f + ' (alaya_bijas, alaya_exported, seed_imports)', bijas: b && b.n, byOrigin: origin, bijasWithActivation: b && b.active, activationsTotal: b && b.acts,
+    syncedInWindow: fresh && fresh.n, seedsExportedTotal: exp && exp.n, seedsExportedInWindow: exp && exp.w, seedImportsInWindow: seeds && seeds.n,
+    note: 'activated_count is cumulative (no per-day record), so activations are all-time, not windowed; hub numbers: no data (no hub endpoint read)',
+  };
+}
+
+function collect({ home = os.homedir(), cwd = process.cwd(), days = 14, now = Date.now() } = {}) {
+  return {
+    days,
+    peer: peerStats({ roots: projectRoots(home, cwd), now, days }),
+    dispatch: dispatchStats({ repo: cwd, now, days }),
+    fieldReports: fieldStats({ home, repo: cwd, now, days }),
+    alaya: alayaStats({ home, now, days }),
+  };
+}
+
+function render(s) {
+  const L = [`kenaz stats (last ${s.days} days, read-only)`, ''];
+  const p = s.peer;
+  L.push('Peer delivery', `  source: ${p.source}`);
+  if (p.received == null) L.push(`  ${p.note}`);
+  else L.push(`  received ${p.received}: delivered ${p.delivered} (push ${p.byPush}, pull ${p.byPull}), pending ${p.pending}; delivered rate ${(p.deliveredRate * 100).toFixed(0)}%`,
+    `  time to delivery: median ${dur(p.medianMs)}, p90 ${dur(p.p90Ms)}`,
+    `  undeliverable reasons: ${Object.keys(p.undeliverableReasons).length ? Object.entries(p.undeliverableReasons).map(([k, v]) => `${k}=${v}`).join(', ') : 'none recorded'}`, `  note: ${p.note}`);
+  const d = s.dispatch;
+  L.push('', 'Dispatch first-pass merge rate', `  source: ${d.source}`);
+  if (d.dispatched == null) L.push(`  ${d.note}`);
+  else {
+    L.push(`  cards ${d.dispatched}: merged ${d.merged}, landed without merge commit ${d.landedWithoutMergeCommit} (not judged), not merged ${d.notMerged}; first-pass ${d.firstPass}/${d.merged}${d.firstPassRate == null ? '' : ` (${(d.firstPassRate * 100).toFixed(0)}%)`}`);
+    for (const r of d.rework) L.push(`  rework: ${r.card} - ${r.why}`);
+    if (d.notMergedCards.length) L.push(`  not merged (first ${d.notMergedCards.length}): ${d.notMergedCards.join(', ')}`);
+  }
+  const f = s.fieldReports;
+  L.push('', 'Field report -> release latency', `  source: ${f.source}`);
+  if (f.reports == null) L.push(`  ${f.note}`);
+  else {
+    L.push(`  reports ${f.reports}: released ${f.released}, closed without a release ${f.closedWithoutRelease} (${Object.entries(f.closedByStatus || {}).map(([k, v]) => `${k}=${v}`).join(", ") || "-"}), open ${f.open.length}, no card yet ${f.withoutCard}; median latency ${dur(f.medianMs)}`);
+    for (const x of f.releasedList) L.push(`  released: ${x.id.slice(0, 8)} ${x.card} -> ${x.tag} after ${dur(x.latencyMs)}`);
+    for (const x of f.open) L.push(`  open: ${x.id.slice(0, 8)} ${x.card} age ${dur(x.ageMs)} (${x.status})`);
+    if (f.note) L.push(`  note: ${f.note}`);
+  }
+  const a = s.alaya;
+  L.push('', 'Alaya (seeds / bijas)', `  source: ${a.source}`);
+  if (a.bijas == null) L.push(`  ${a.note}`);
+  else {
+    L.push(`  local alaya_bijas ${a.bijas} (${(a.byOrigin || []).map((o) => `${o.origin}=${o.n}`).join(', ') || NO_DATA}); synced in window ${a.syncedInWindow}`,
+      `  activated: ${a.bijasWithActivation || 0} bijas with >=1 activation, ${a.activationsTotal} activations all-time`,
+      `  seeds exported: ${a.seedsExportedTotal} all-time, ${a.seedsExportedInWindow || 0} in window; seed imports in window ${a.seedImportsInWindow}`, `  note: ${a.note}`);
+  }
+  return L.join('\n');
+}
+
+function main(argv, out = console.log, opts = {}) {
+  const i = argv.indexOf('--days');
+  const days = i >= 0 ? Number(argv[i + 1]) : 14;
+  if (!(days > 0)) { out('usage: kenaz stats [--days N] [--json]'); return 2; }
+  const s = collect({ ...opts, days });
+  out(argv.includes('--json') ? JSON.stringify(s, null, 2) : render(s));
+  return 0;
+}
+
+if (require.main === module) process.exit(main(process.argv.slice(2)));
+module.exports = { main, collect, peerStats, dispatchStats, fieldStats, alayaStats, render };

package/core/.formation/tools/kenaz-stats.test.js

@@ -0,0 +1,180 @@
+// TASK_2408: kenaz stats fixture tests (temp dirs only, never the real ~/.kenaz).
+// Usage: node .formation/tools/kenaz-stats.test.js
+'use strict';
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { DatabaseSync } = require('node:sqlite');
+const S = require('./kenaz-stats');
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'kenaz-stats-'));
+const NOW = Date.parse('2026-10-11T12:00:00Z');
+const iso = (d, h = 0, m = 0, s = 0) => new Date(NOW - d * 86400000 + (h * 3600 + m * 60 + s) * 1000).toISOString();
+const tests = [];
+const test = (name, fn) => tests.push([name, fn]);
+
+function db(file, sql) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const d = new DatabaseSync(file); d.exec(sql); d.close();
+}
+
+test('peer: delivered by push / pull / pending, median and p90, reasons, window and "no data"', () => {
+  const root = path.join(tmp, 'peer-proj');
+  const f = path.join(root, '.kenaz', 'peer', 'inbox.sqlite');
+  const row = (id, dir, created, d, deliveredAt, pushed, state) =>
+    `INSERT INTO peer_messages(id,thread_id,from_node,to_node,kind,body,direction,created_at,delivered_to_session,delivered_at,pushed_at,delivery_state) VALUES('${id}','t','a','b','msg','x','${dir}','${created}',${d},${deliveredAt ? `'${deliveredAt}'` : 'NULL'},${pushed ? `'${pushed}'` : 'NULL'},${state ? `'${state}'` : 'NULL'});`;
+  db(f, `CREATE TABLE peer_messages(id TEXT PRIMARY KEY, thread_id TEXT, from_node TEXT, to_node TEXT, kind TEXT, body TEXT, direction TEXT, created_at TEXT, delivered_to_session INTEGER, delivered_at TEXT, pushed_at TEXT, delivery_state TEXT);` + [
+    row('1', 'in', iso(1), 1, iso(1, 0, 0, 10), iso(1), null), // push, 10s
+    row('2', 'in', iso(1), 1, iso(1, 0, 1, 0), iso(1), null), // push, 60s
+    row('3', 'in', iso(2), 1, iso(2, 1, 0, 0), null, null), // pull, 1h
+    row('4', 'in', iso(2), 0, null, null, 'waiting_no_session'), // pending, undeliverable
+    row('5', 'out', iso(1), 0, null, null, null), // outbound: ignored
+    row('6', 'in', iso(30), 1, iso(30, 0, 0, 1), iso(30), null), // outside window
+  ].join(''));
+  const p = S.peerStats({ roots: [root], now: NOW, days: 14 });
+  assert.strictEqual(p.received, 4);
+  assert.strictEqual(p.delivered, 3);
+  assert.strictEqual(p.byPush, 2);
+  assert.strictEqual(p.byPull, 1);
+  assert.strictEqual(p.pending, 1);
+  assert.strictEqual(p.medianMs, 60000);
+  assert.strictEqual(p.p90Ms, 3600000);
+  assert.deepStrictEqual(p.undeliverableReasons, { waiting_no_session: 1 });
+  const none = S.peerStats({ roots: [path.join(tmp, 'absent')], now: NOW, days: 14 });
+  assert.ok(none.note.startsWith('no data') && none.received === undefined);
+});
+
+let repoMemo;
+function repo() {
+  if (repoMemo) return repoMemo;
+  const dir = path.join(tmp, 'repo');
+  fs.mkdirSync(dir);
+  const g = (...a) => execFileSync('git', a, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  g('init', '-q', '-b', 'main');
+  g('config', 'user.email', 't@t'); g('config', 'user.name', 't'); g('config', 'commit.gpgsign', 'false');
+  let n = 0;
+  const commit = (msg, when) => { fs.writeFileSync(path.join(dir, 'f.txt'), String(++n)); g('add', '.'); execFileSync('git', ['commit', '-q', '-m', msg], { cwd: dir, env: { ...process.env, GIT_AUTHOR_DATE: when, GIT_COMMITTER_DATE: when } }); };
+  // merge a task branch like dispatch does: branch commit + --no-ff merge
+  let b = 0;
+  const land = (card, when, extra) => {
+    const br = `task/${card}-${++b}`;
+    g('checkout', '-q', '-b', br);
+    commit(`[${card}] task completed`, when);
+    g('checkout', '-q', 'main');
+    execFileSync('git', ['merge', '--no-ff', '-q', '-m', `Merge ${card}: done`, br], { cwd: dir, env: { ...process.env, GIT_AUTHOR_DATE: when, GIT_COMMITTER_DATE: when } });
+    if (extra) commit(extra, iso(0, -5));
+  };
+  commit('base', iso(20));
+  land('TASK_1', iso(10)); // clean first pass
+  land('TASK_2', iso(9), '[TASK_2] fix-up after the merge'); // fix-up on main
+  land('TASK_3', iso(8));
+  land('TASK_3', iso(7)); // re-dispatched
+  g('checkout', '-q', '-b', 'task/TASK_4'); commit('[TASK_4] wip', iso(6)); g('checkout', '-q', 'main'); // never merged
+  return (repoMemo = { dir, g, commit });
+}
+
+test('dispatch: first-pass rate, rework list (fix-up commit and re-dispatch), unmerged', () => {
+  const r = repo();
+  const d = S.dispatchStats({ repo: r.dir, now: NOW, days: 14 });
+  assert.strictEqual(d.dispatched, 4);
+  assert.strictEqual(d.merged, 3);
+  assert.deepStrictEqual(d.notMergedCards, ['TASK_4']);
+  assert.strictEqual(d.firstPass, 1);
+  assert.deepStrictEqual(d.rework.map((x) => x.card).sort(), ['TASK_2', 'TASK_3']);
+  assert.ok(Math.abs(d.firstPassRate - 1 / 3) < 1e-9);
+  assert.ok(S.dispatchStats({ repo: path.join(tmp, 'nogit'), now: NOW, days: 14 }).note.startsWith('no data'));
+});
+
+test('field reports: latency to first release tag containing the merge, median, open with age', () => {
+  const r = repo(); // tag v1.0.0 on TASK_1's merge only
+  const mergeSha = (card) => r.g('log', '--all', '--format=%H', `--grep=^Merge ${card}:`).trim().split('\n')[0];
+  execFileSync('git', ['tag', '-a', 'v1.0.0', '-m', 'r', mergeSha('TASK_1')], { cwd: r.dir, env: { ...process.env, GIT_COMMITTER_DATE: iso(5) } });
+  const home = path.join(tmp, 'home');
+  db(path.join(home, '.kenaz', 'cortex', 'field_reports.db'), `CREATE TABLE field_reports(id TEXT PRIMARY KEY, card_id TEXT, received_at TEXT, kind TEXT, quarantined INTEGER DEFAULT 0);
+    INSERT INTO field_reports(id,card_id,received_at,kind) VALUES('aaaaaaaa-1','TASK_1','${iso(11)}','bug');
+    INSERT INTO field_reports(id,card_id,received_at,kind) VALUES('bbbbbbbb-2','TASK_2','${iso(10)}','bug');
+    INSERT INTO field_reports(id,card_id,received_at,kind) VALUES('cccccccc-3','TASK_99','${iso(3)}','bug');
+    INSERT INTO field_reports(id,card_id,received_at,kind) VALUES('dddddddd-4',NULL,'${iso(2)}','bug');
+    INSERT INTO field_reports(id,card_id,received_at,kind) VALUES('eeeeeeee-5','TASK_1','${iso(40)}','bug');`);
+  const f = S.fieldStats({ home, repo: r.dir, now: NOW, days: 14 });
+  assert.strictEqual(f.reports, 4); // 40 days old is outside the window
+  assert.strictEqual(f.released, 1);
+  assert.strictEqual(f.releasedList[0].tag, 'v1.0.0');
+  assert.strictEqual(f.medianMs, 6 * 86400000);
+  assert.deepStrictEqual(f.open.map((x) => x.card).sort(), ['TASK_2', 'TASK_99']);
+  assert.strictEqual(f.open.find((x) => x.card === 'TASK_2').ageMs, 10 * 86400000);
+  assert.strictEqual(f.withoutCard, 1);
+  assert.ok(S.fieldStats({ home: path.join(tmp, 'nohome'), repo: r.dir, now: NOW, days: 14 }).note.startsWith('no data'));
+});
+
+test('dispatch rework also counts an abandoned delivery and commits added on the branch after delivery; closed cards are not open', () => {
+  const dir = path.join(tmp, 'repo2');
+  fs.mkdirSync(dir);
+  const g = (...a) => execFileSync('git', a, { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+  g('init', '-q', '-b', 'main'); g('config', 'user.email', 't@t'); g('config', 'user.name', 't'); g('config', 'commit.gpgsign', 'false');
+  let n = 0;
+  const commit = (msg) => { fs.writeFileSync(path.join(dir, 'f.txt'), String(++n)); g('add', 'f.txt'); execFileSync('git', ['commit', '-q', '-m', msg], { cwd: dir, env: { ...process.env, GIT_AUTHOR_DATE: iso(3), GIT_COMMITTER_DATE: iso(3) } }); };
+  const merge = (br, card) => { g('checkout', '-q', 'main'); execFileSync('git', ['merge', '--no-ff', '-q', '-m', `Merge ${card}: x`, br], { cwd: dir, env: { ...process.env, GIT_AUTHOR_DATE: iso(2), GIT_COMMITTER_DATE: iso(2) } }); };
+  commit('base');
+  g('checkout', '-q', '-b', 'arm-a'); commit('[TASK_7] task completed'); g('checkout', '-q', 'main'); // losing A/B arm, never merged
+  g('checkout', '-q', '-b', 'arm-b'); commit('[TASK_7] task completed'); merge('arm-b', 'TASK_7');
+  g('checkout', '-q', '-b', 'b8'); commit('[TASK_8] task completed'); commit('[TASK_8] task completed'); merge('b8', 'TASK_8'); // agent's own follow-up: first pass
+  g('checkout', '-q', '-b', 'b9'); commit('[TASK_9] task completed'); commit('[TASK_9] reviewer fix before merge'); merge('b9', 'TASK_9');
+  const d = S.dispatchStats({ repo: dir, now: NOW, days: 14 });
+  const why = Object.fromEntries(d.rework.map((x) => [x.card, x.why]));
+  assert.match(why.TASK_7, /never merged/);
+  assert.match(why.TASK_9, /after the agent's delivery/);
+  assert.ok(!why.TASK_8, 'the agent re-committing its own work is still first pass');
+  // field report whose card was closed (cancel) without a commit naming it
+  fs.mkdirSync(path.join(dir, '.kenaz', 'tasks', 'cancel'), { recursive: true });
+  fs.writeFileSync(path.join(dir, '.kenaz', 'tasks', 'cancel', 'TASK_99_dup.yaml'), 'id: TASK_99\n');
+  const home = path.join(tmp, 'home2');
+  db(path.join(home, '.kenaz', 'cortex', 'field_reports.db'), `CREATE TABLE field_reports(id TEXT PRIMARY KEY, card_id TEXT, received_at TEXT, kind TEXT, quarantined INTEGER DEFAULT 0);
+    INSERT INTO field_reports(id,card_id,received_at,kind) VALUES('ffffffff-1','TASK_99','${iso(3)}','bug');
+    INSERT INTO field_reports(id,card_id,received_at,kind) VALUES('ffffffff-2','TASK_98','${iso(3)}','bug');`);
+  const f = S.fieldStats({ home, repo: dir, now: NOW, days: 14 });
+  assert.strictEqual(f.closedWithoutRelease, 1);
+  assert.deepStrictEqual(f.closedByStatus, { cancel: 1 });
+  assert.deepStrictEqual(f.open.map((x) => x.card), ['TASK_98']);
+  assert.match(f.open[0].status, /card not found/);
+});
+
+test('alaya: bija counts, activations, exported and seed imports in window; missing db says no data', () => {
+  const home = path.join(tmp, 'home2');
+  db(path.join(home, '.kenaz', 'cortex', 'global_memory.db'), `
+    CREATE TABLE alaya_bijas(id TEXT PRIMARY KEY, synced_at TEXT, activated_count INTEGER, origin TEXT);
+    CREATE TABLE alaya_exported(original_id TEXT PRIMARY KEY, exported_at TEXT);
+    CREATE TABLE seed_imports(seed_version TEXT PRIMARY KEY, imported_at TEXT);
+    INSERT INTO alaya_bijas VALUES('a','2026-10-10 00:00:00',3,'remote'),('b','2026-09-01 00:00:00',0,'remote'),('c','2026-10-09 00:00:00',2,'local');
+    INSERT INTO alaya_exported VALUES('x','2026-10-10 00:00:00'),('y','2026-08-01 00:00:00');
+    INSERT INTO seed_imports VALUES('v1','${iso(3)}');`);
+  const a = S.alayaStats({ home, now: NOW, days: 14 });
+  assert.strictEqual(a.bijas, 3);
+  assert.strictEqual(a.bijasWithActivation, 2);
+  assert.strictEqual(a.activationsTotal, 5);
+  assert.strictEqual(a.syncedInWindow, 2);
+  assert.strictEqual(a.seedsExportedTotal, 2);
+  assert.strictEqual(a.seedsExportedInWindow, 1);
+  assert.strictEqual(a.seedImportsInWindow, 1);
+  assert.ok(S.alayaStats({ home: path.join(tmp, 'nohome'), now: NOW, days: 14 }).note.startsWith('no data'));
+});
+
+test('main: --json parses and all four sections print; bad --days exits 2', () => {
+  const lines = [];
+  assert.strictEqual(S.main(['--json'], (m) => lines.push(m), { home: path.join(tmp, 'home2'), cwd: path.join(tmp, 'repo'), now: NOW }), 0);
+  assert.deepStrictEqual(Object.keys(JSON.parse(lines[0])), ['days', 'peer', 'dispatch', 'fieldReports', 'alaya']);
+  const text = [];
+  S.main([], (m) => text.push(m), { home: path.join(tmp, 'nohome'), cwd: path.join(tmp, 'nogit'), now: NOW });
+  for (const h of ['Peer delivery', 'Dispatch first-pass merge rate', 'Field report -> release latency', 'Alaya']) assert.ok(text[0].includes(h), h);
+  assert.ok(!/\b0%/.test(text[0]) && text[0].includes('no data'));
+  assert.strictEqual(S.main(['--days', 'x'], () => {}), 2);
+});
+
+let failed = 0;
+for (const [name, fn] of tests) {
+  try { fn(); console.log('ok   ' + name); } catch (e) { failed++; console.log('FAIL ' + name + '\n  ' + (e.stack || e)); }
+}
+try { fs.rmSync(tmp, { recursive: true, force: true }); } catch (_) { /* best effort */ }
+process.exit(failed ? 1 : 0);

package/core/.formation/tools/mcp-allowlist.test.js

@@ -11,7 +11,9 @@ const MCP_RS = path.join(ROOT, 'dashboard', 'src-tauri', 'src', 'infrastructure'
 const ALLOWLIST_FILES = [
   '.specialist/Ansuz/tools/ansuz-sdk-runner.js',
 ];
-const REMOVED = ['synapse_associate', 'synapse_audit', 'synapse_apply_usage_boosts', 'synapse_pulse', 'synapse_thought_push', 'synapse_verify', 'cortex_search'];
+const REMOVED = ['synapse_associate', 'synapse_audit', 'synapse_apply_usage_boosts', 'synapse_pulse', 'synapse_thought_push', 'synapse_verify', 'cortex_search',
+  // TASK_2411: the memory system
+  'synapse_recall', 'synapse_inscribe', 'synapse_forge', 'synapse_status', 'hippocampus_episode_start', 'cortex_recall', 'alaya_recall'];
 
 function dispatchedTools() {
   const src = fs.readFileSync(MCP_RS, 'utf8');
@@ -22,9 +24,9 @@ function dispatchedTools() {
   return new Set([...src.slice(start, end).matchAll(/^\s*"([a-z0-9_]+)"\s*=>/gm)].map(m => m[1]));
 }
 
-test('dispatcher tool list is non-trivial and contains the memory/LSP tools', () => {
+test('dispatcher tool list is non-trivial and contains the LSP tools and none of the removed memory tools', () => {
   const tools = dispatchedTools();
-  for (const t of ['synapse_recall', 'synapse_inscribe', 'kenaz_lsp_callers', 'hippocampus_episode_start', 'cortex_recall']) assert.ok(tools.has(t), t);
+  for (const t of ['kenaz_lsp_callers', 'kenaz_ping', 'alaya_reports_list']) assert.ok(tools.has(t), t);
   for (const t of REMOVED) assert.ok(!tools.has(t), `${t} should not be dispatched`);
 });
 

package/core/.formation/tools/post-complete/bounded-http.js

@@ -60,43 +60,4 @@ function getJson(endpoint, opts) {
   return httpJson('GET', endpoint, undefined, opts);
 }
 
-function classifyInscribe(response, id, args) {
-  if (!response.ok) return { status: 'failed', reason: response.reason };
-  const rpc = response.data;
-  if (!rpc || rpc.error || rpc.id !== id || rpc.jsonrpc !== '2.0') return { status: 'failed', reason: 'rpc_error' };
-  const result = rpc.result;
-  if (!result || (result.isError != null && result.isError !== false) || !Array.isArray(result.content)) return { status: 'failed', reason: 'mcp_error' };
-  try {
-    const texts = result.content.filter(c => c && c.type === 'text');
-    if (texts.length !== 1) throw new Error('shape');
-    const data = JSON.parse(texts[0].text);
-    if (!data || data.error || data.success === false || data.gate_fired || data.symbol_id !== args.symbol_id) throw new Error('result');
-    if (data.outcome === 'SPOOLED' && typeof data.spool_id === 'string' && data.spool_id &&
-        typeof data.spool_file === 'string' && data.spool_file) return { status: 'spooled' };
-    if (!data.outcome && typeof data.rune_id === 'string' && data.rune_id && data.type === args.type) return { status: 'successful' };
-  } catch { /* No confirmed acknowledgement. */ }
-  return { status: 'failed', reason: 'unconfirmed_result' };
-}
-
-async function inscribeBatch(items, { timeoutMs = 10000, request = postJson, endpoint = {} } = {}) {
-  const counts = { successful: 0, spooled: 0, failed: 0, skipped: 0, reason: null };
-  const deadline = Date.now() + timeoutMs;
-  for (let i = 0; i < items.length; i++) {
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) { counts.reason = 'batch_deadline'; break; }
-    const id = `rune-extract-${deadline}-${i}`;
-    let verdict;
-    try {
-      const response = await request({ ...endpoint, path: '/api/mcp' }, {
-        jsonrpc: '2.0', id, method: 'tools/call', params: { name: 'synapse_inscribe', arguments: items[i] },
-      }, { timeoutMs: remaining });
-      verdict = classifyInscribe(response, id, items[i]);
-    } catch { verdict = { status: 'failed', reason: 'request_error' }; }
-    counts[verdict.status]++;
-    if (verdict.status === 'failed') { counts.reason = verdict.reason; break; }
-  }
-  counts.skipped = items.length - counts.successful - counts.spooled - counts.failed;
-  return counts;
-}
-
-module.exports = { postJson, getJson, classifyInscribe, inscribeBatch };
+module.exports = { postJson, getJson };

package/core/.formation/tools/post-complete/bounded-http.test.js

@@ -2,33 +2,7 @@
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
 const http = require('node:http');
-const { postJson, inscribeBatch } = require('./bounded-http');
-
-test('passive extraction caps the batch at 20 and emits one truthful failure summary', async () => {
-  const fs = require('node:fs');
-  const vm = require('node:vm');
-  const sourcePath = require.resolve('./cognitive');
-  const localRequire = require('node:module').createRequire(sourcePath);
-  const mod = { exports: {} }, logs = [];
-  let batches = 0, requests = 0;
-  const ctx = { module: mod, console: { log: s => logs.push(s), warn: s => logs.push(s) },
-    require: name => name === './bounded-http' ? { inscribeBatch: async values => {
-      batches++;
-      assert.equal(values.length, 20);
-      assert.ok(values.every(v => v.projectPath === 'fixture-project'));
-      return inscribeBatch(values, { request: async () => { requests++; throw new Error('fixture'); } });
-    } } : localRequire(name),
-  };
-  vm.runInNewContext(fs.readFileSync(sourcePath, 'utf8'), ctx);
-  mod.exports.initCognitive({ getPostCompleteChangedFiles: () => Array.from({ length: 25 }, (_, i) => `file${i}.js`), stripCJK: s => s });
-  const result = await mod.exports.triggerPassiveRuneExtraction('fix: fixture', 'fixture-root', 'fixture-project');
-  assert.equal(batches, 1);
-  assert.equal(requests, 1);
-  assert.equal(result.failed, 1);
-  assert.equal(result.skipped, 19);
-  assert.equal(logs.length, 1);
-  assert.match(logs[0], /successful=0, spooled=0, failed=1, skipped=19/);
-});
+const { postJson } = require('./bounded-http');
 
 async function server(t, handler) {
   const s = http.createServer(handler);
@@ -36,54 +10,12 @@ async function server(t, handler) {
   t.after(() => new Promise(resolve => { s.closeAllConnections(); s.close(resolve); }));
   return { hostname: '127.0.0.1', port: s.address().port };
 }
-const items = () => [0, 1, 2].map(i => ({ symbol_id: `file${i}.js`, type: 'summary', projectPath: 'fixture-project', content: 'fixture' }));
-function rpc(payload, data, isError = false) {
-  return { ok: true, data: { jsonrpc: '2.0', id: payload.id,
-    result: { content: [{ type: 'text', text: JSON.stringify(data) }], isError } } };
-}
-
-test('written and server-spooled acknowledgements are separate; project routing survives', async () => {
-  let calls = 0;
-  const result = await inscribeBatch(items(), { request: async (_endpoint, payload) => {
-    const args = payload.params.arguments;
-    assert.equal(args.projectPath, 'fixture-project');
-    calls++;
-    if (calls === 1) return rpc(payload, { rune_id: 'rune_one', symbol_id: args.symbol_id, type: args.type });
-    if (calls === 2) return rpc(payload, { outcome: 'SPOOLED', spool_id: 'spool_one', spool_file: 'fixture-spool.json', symbol_id: args.symbol_id });
-    return rpc(payload, { error: 'rejected' }, true);
-  } });
-  assert.deepEqual(result, { successful: 1, spooled: 1, failed: 1, skipped: 0, reason: 'mcp_error' });
-});
-
-for (const fault of ['transport', 'rpc', 'mcp', 'text_json', 'unknown', 'gate', 'spool_without_receipt', 'wrong_id']) {
-  test('first ' + fault + ' failure stops batch without marking unsent writes successful', async () => {
-    let calls = 0;
-    const result = await inscribeBatch(items(), { request: async (_endpoint, payload) => {
-      calls++;
-      if (fault === 'transport') throw new Error('fixture transport');
-      if (fault === 'rpc') return { ok: true, data: { error: { code: -32000 } } };
-      if (fault === 'mcp') return rpc(payload, {}, true);
-      if (fault === 'text_json') { const r = rpc(payload, {}); r.data.result.content[0].text = 'bad'; return r; }
-      if (fault === 'gate') return rpc(payload, { gate_fired: true, rune_id: 'existing', symbol_id: 'file0.js', type: 'summary' });
-      if (fault === 'spool_without_receipt') return rpc(payload, { outcome: 'SPOOLED', symbol_id: 'file0.js' });
-      if (fault === 'wrong_id') { const r = rpc(payload, { rune_id: 'one', symbol_id: 'file0.js', type: 'summary' }); r.data.id = 'other'; return r; }
-      return rpc(payload, { success: true });
-    } });
-    assert.equal(calls, 1);
-    assert.equal(result.successful, 0);
-    assert.equal(result.spooled, 0);
-    assert.equal(result.failed, 1);
-    assert.equal(result.skipped, 2);
-  });
-}
-
 test('HTTP failure and invalid JSON fail closed', async t => {
   let calls = 0;
   const endpoint = await server(t, (_req, res) => { calls++; res.writeHead(503); res.end('{}'); });
-  const result = await inscribeBatch(items(), { endpoint });
+  const result = await postJson(endpoint, {});
   assert.equal(calls, 1);
   assert.equal(result.reason, 'http_503');
-  assert.equal(result.skipped, 2);
   const malformed = await server(t, (_req, res) => res.end('not-json'));
   assert.deepEqual(await postJson(malformed, {}), { ok: false, reason: 'invalid_json' });
 });
@@ -109,22 +41,3 @@ test('body size is bounded and disconnected response fails once', async t => {
   assert.equal(result.ok, false);
   assert.match(result.reason, /transport_error|response_aborted|response_error/);
 });
-
-test('batch uses one deadline and serial requests; timeout skips remaining items', async t => {
-  let calls = 0;
-  const endpoint = await server(t, (req, res) => {
-    calls++;
-    let body = '';
-    req.on('data', b => { body += b; });
-    req.on('end', () => {
-      if (calls !== 1) return;
-      const payload = JSON.parse(body);
-      setTimeout(() => res.end(JSON.stringify(rpc(payload, { rune_id: 'one', symbol_id: 'file0.js', type: 'summary' }).data)), 20);
-    });
-  });
-  const start = Date.now();
-  const result = await inscribeBatch(items(), { endpoint, timeoutMs: 100 });
-  assert.deepEqual(result, { successful: 1, spooled: 0, failed: 1, skipped: 1, reason: 'timeout' });
-  assert.equal(calls, 2);
-  assert.ok(Date.now() - start < 1000);
-});