kenaz 0.0.0-stage → 0.3.2

package/core/.formation/tools/pool-status-push.test.js

@@ -0,0 +1,165 @@
+'use strict';
+
+/**
+ * pool-status-push.test.js (TASK_2142 R2)
+ *
+ * Unit tests for pushPoolStatus()/poolOriginOf() with an injected fetch --
+ * never touches a real dashboard backend or relay. Covers:
+ *   - a pool-origin card + tracked status -> POSTs the right payload
+ *   - a non-pool card -> never fetches
+ *   - an untracked status (e.g. backlog) -> never fetches
+ *   - fetch rejecting / non-ok / malformed JSON -> resolves {pushed:false}, never throws
+ *
+ * Run: node --test .formation/tools/pool-status-push.test.js
+ */
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { pushPoolStatus, poolOriginOf, STATUS_MAP } = require('./pool-status-push');
+
+function poolTask(overrides) {
+  return {
+    id: 'TASK_2142',
+    title: 'x',
+    metadata: {
+      pool_origin_project: 'my-room',
+      pool_relay_task_id: 'my-room:TASK_2142',
+    },
+    ...overrides,
+  };
+}
+
+test('poolOriginOf: pool-origin card returns {project, relayTaskId}', () => {
+  const origin = poolOriginOf(poolTask());
+  assert.deepEqual(origin, { project: 'my-room', relayTaskId: 'my-room:TASK_2142' });
+});
+
+test('poolOriginOf: card with no metadata -> null', () => {
+  assert.equal(poolOriginOf({ id: 'X' }), null);
+});
+
+test('poolOriginOf: metadata present but markers missing -> null', () => {
+  assert.equal(poolOriginOf({ id: 'X', metadata: { migrated_from: 'y' } }), null);
+});
+
+test('pushPoolStatus: pool-origin card + tracked status (active) -> POSTs to the local dashboard backend with the right payload', async () => {
+  const calls = [];
+  const fakeFetch = async (url, init) => {
+    calls.push({ url, init });
+    return { ok: true, status: 200, json: async () => ({ ok: true, task_id: 'my-room:TASK_2142' }) };
+  };
+
+  const result = await pushPoolStatus(
+    { targetDir: 'active', task: poolTask(), fullYaml: 'id: TASK_2142\nstatus: in_progress\n', projectPath: '/repo' },
+    fakeFetch
+  );
+
+  assert.equal(result.pushed, true);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].url, 'http://127.0.0.1:18080/api/pool/push-status');
+  assert.equal(calls[0].init.method, 'POST');
+  const body = JSON.parse(calls[0].init.body);
+  assert.deepEqual(body, {
+    projectPath: '/repo',
+    poolRelayTaskId: 'my-room:TASK_2142',
+    status: 'in_progress',
+    fullYaml: 'id: TASK_2142\nstatus: in_progress\n',
+  });
+});
+
+for (const [targetDir, relayStatus] of Object.entries(STATUS_MAP)) {
+  test(`pushPoolStatus: targetDir '${targetDir}' maps to relay status '${relayStatus}'`, async () => {
+    let seenStatus = null;
+    const fakeFetch = async (_url, init) => {
+      seenStatus = JSON.parse(init.body).status;
+      return { ok: true, status: 200, json: async () => ({ ok: true }) };
+    };
+    const result = await pushPoolStatus({ targetDir, task: poolTask() }, fakeFetch);
+    assert.equal(result.pushed, true);
+    assert.equal(seenStatus, relayStatus);
+  });
+}
+
+test('pushPoolStatus: non-pool card -> never fetches, resolves {pushed:false}', async () => {
+  let fetchCalled = false;
+  const fakeFetch = async () => { fetchCalled = true; return { ok: true, json: async () => ({ ok: true }) }; };
+
+  const result = await pushPoolStatus({ targetDir: 'active', task: { id: 'X' } }, fakeFetch);
+
+  assert.equal(fetchCalled, false);
+  assert.equal(result.pushed, false);
+  assert.equal(result.reason, 'not-pool-origin');
+});
+
+test('pushPoolStatus: untracked status (backlog) -> never fetches even for a pool card', async () => {
+  let fetchCalled = false;
+  const fakeFetch = async () => { fetchCalled = true; return { ok: true, json: async () => ({ ok: true }) }; };
+
+  const result = await pushPoolStatus({ targetDir: 'backlog', task: poolTask() }, fakeFetch);
+
+  assert.equal(fetchCalled, false);
+  assert.equal(result.pushed, false);
+  assert.equal(result.reason, 'not-a-tracked-status');
+});
+
+test('pushPoolStatus: fetch rejects (backend down) -> resolves {pushed:false}, never throws', async () => {
+  const fakeFetch = async () => { throw new Error('ECONNREFUSED'); };
+
+  const result = await pushPoolStatus({ targetDir: 'done', task: poolTask() }, fakeFetch);
+
+  assert.equal(result.pushed, false);
+  assert.equal(result.reason, 'exception');
+});
+
+test('pushPoolStatus: HTTP non-ok response -> resolves {pushed:false}, never throws', async () => {
+  const fakeFetch = async () => ({ ok: false, status: 500, json: async () => ({}) });
+
+  const result = await pushPoolStatus({ targetDir: 'blocked', task: poolTask() }, fakeFetch);
+
+  assert.equal(result.pushed, false);
+  assert.equal(result.reason, 'http-500');
+});
+
+test('pushPoolStatus: relay reports ok:false in body (e.g. row disappeared, mixed-version fleet) -> resolves {pushed:false}, never throws', async () => {
+  const fakeFetch = async () => ({ ok: true, status: 200, json: async () => ({ ok: false, relay_status_code: 404 }) });
+
+  const result = await pushPoolStatus({ targetDir: 'cancel', task: poolTask() }, fakeFetch);
+
+  assert.equal(result.pushed, false);
+});
+
+test('pushPoolStatus: malformed JSON body -> resolves {pushed:false}, never throws', async () => {
+  const fakeFetch = async () => ({ ok: true, status: 200, json: async () => { throw new Error('bad json'); } });
+
+  const result = await pushPoolStatus({ targetDir: 'done', task: poolTask() }, fakeFetch);
+
+  assert.equal(result.pushed, false);
+});
+
+// TASK_2238: a client-side abort is an UNKNOWN outcome, not a confirmed failure.
+test('pushPoolStatus: AbortError (5s timeout) -> reason timeout, warns "timed out / outcome unknown", not "failed"', async () => {
+  const fakeFetch = async () => { const e = new Error('This operation was aborted'); e.name = 'AbortError'; throw e; };
+  const warns = [];
+  const origWarn = console.warn;
+  console.warn = (...a) => warns.push(a.join(' '));
+  let result;
+  try { result = await pushPoolStatus({ targetDir: 'done', task: poolTask() }, fakeFetch); } finally { console.warn = origWarn; }
+
+  assert.equal(result.pushed, false);
+  assert.equal(result.reason, 'timeout');
+  assert.equal(warns.length, 1);
+  assert.match(warns[0], /timed out/);
+  assert.match(warns[0], /outcome unknown/);
+  assert.doesNotMatch(warns[0], /failed/);
+});
+
+test('pushPoolStatus: non-abort rejection still reports "failed" (control)', async () => {
+  const fakeFetch = async () => { throw new Error('ECONNREFUSED'); };
+  const warns = [];
+  const origWarn = console.warn;
+  console.warn = (...a) => warns.push(a.join(' '));
+  try { await pushPoolStatus({ targetDir: 'done', task: poolTask() }, fakeFetch); } finally { console.warn = origWarn; }
+
+  assert.match(warns[0], /push-status failed/);
+});

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

@@ -0,0 +1,102 @@
+'use strict';
+const http = require('http');
+
+// Absolute deadline covers connect, headers and body (socket inactivity is not
+// a total deadline). No retries: a lost response may already have been written.
+//
+// Shared core for postJson/getJson (TASK_1997): both are bounded, single-shot,
+// fail-closed JSON-over-HTTP calls against the local dashboard — only the verb
+// and whether a body is sent differ, so they share one implementation instead
+// of two near-identical copies.
+function httpJson(method, endpoint, payload, { timeoutMs = 10000, maxBytes = 1024 * 1024 } = {}) {
+  return new Promise(resolve => {
+    let done = false, req, response;
+    const finish = result => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (!result.ok) { if (response) response.destroy(); if (req) req.destroy(); }
+      resolve(result);
+    };
+    const timer = setTimeout(() => finish({ ok: false, reason: 'timeout' }), timeoutMs);
+    try {
+      const hasBody = payload !== undefined;
+      const body = hasBody ? JSON.stringify(payload) : null;
+      const headers = hasBody ? { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } : {};
+      req = http.request({ hostname: '127.0.0.1', port: 18080, ...endpoint, method, headers }, res => {
+        response = res;
+        if (done) { res.destroy(); return; }
+        res.on('error', () => finish({ ok: false, reason: 'response_error' }));
+        res.on('aborted', () => finish({ ok: false, reason: 'response_aborted' }));
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          finish({ ok: false, reason: 'http_' + res.statusCode }); return;
+        }
+        let size = 0;
+        const chunks = [];
+        res.on('data', chunk => {
+          if (done) return;
+          size += chunk.length;
+          if (size > maxBytes) { finish({ ok: false, reason: 'response_too_large' }); return; }
+          chunks.push(chunk);
+        });
+        res.on('end', () => {
+          if (done) return;
+          try { finish({ ok: true, data: JSON.parse(Buffer.concat(chunks).toString('utf8')) }); }
+          catch { finish({ ok: false, reason: 'invalid_json' }); }
+        });
+      });
+      req.on('error', () => finish({ ok: false, reason: 'transport_error' }));
+      if (hasBody) req.end(body); else req.end();
+    } catch { finish({ ok: false, reason: 'request_error' }); }
+  });
+}
+
+function postJson(endpoint, payload, opts) {
+  return httpJson('POST', endpoint, payload, opts);
+}
+
+// GET counterpart (TASK_1997): no request body, same bounded/fail-closed contract.
+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 };

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

@@ -0,0 +1,130 @@
+'use strict';
+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/);
+});
+
+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 { 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 });
+  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' });
+});
+
+test('absolute deadline handles delayed headers and a continuously streaming body', async t => {
+  const noHeaders = await server(t, () => {});
+  assert.deepEqual(await postJson(noHeaders, {}, { timeoutMs: 30 }), { ok: false, reason: 'timeout' });
+  const streaming = await server(t, (_req, res) => {
+    res.writeHead(200);
+    const interval = setInterval(() => res.write(' '), 5);
+    res.on('close', () => clearInterval(interval));
+  });
+  const started = Date.now();
+  assert.deepEqual(await postJson(streaming, {}, { timeoutMs: 50 }), { ok: false, reason: 'timeout' });
+  assert.ok(Date.now() - started < 1000);
+});
+
+test('body size is bounded and disconnected response fails once', async t => {
+  const large = await server(t, (_req, res) => res.end('x'.repeat(100)));
+  assert.deepEqual(await postJson(large, {}, { maxBytes: 32 }), { ok: false, reason: 'response_too_large' });
+  const dropped = await server(t, (_req, res) => { res.writeHead(200); res.write('{'); res.destroy(); });
+  const result = await postJson(dropped, {});
+  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);
+});

package/core/.formation/tools/post-complete/cognitive.js

@@ -0,0 +1,270 @@
+/**
+ * COGNITIVE — extracted from post-complete.js (D.4 refactor)
+ *
+ * Cognitive checkpoint detection, thinking tags, passive rune extraction,
+ * cognitive attribution, Hippocampus MCP sync, cognitive tool usage tracking,
+ * and cognitive competence map.
+ */
+
+const path = require('path');
+const fs = require('fs');
+const { execSync, spawnSync } = require('child_process');
+const { ROOT, COLLABORATION_API, LOG_DIR, getLogDir } = require('../utils');
+// TASK_2275: kenaz-core ships without node_modules; fall back to the vendored copy.
+const yaml = (() => { try { return require('js-yaml'); } catch { return require('../../../.vendor/js-yaml.cjs'); } })();
+
+// Dependencies injected from post-complete.js (avoids circular require)
+let _deps = {};
+function initCognitive(deps) { _deps = deps; }
+function findLogForTask(t, p) { return _deps.findLogForTask(t, p); }
+function getPostCompleteChangedFiles(r, g) { return _deps.getPostCompleteChangedFiles(r, g); }
+function rankTouchedFiles(r, s, l) { return _deps.rankTouchedFiles(r, s, l); }
+function stripCJK(t) { return _deps.stripCJK(t); }
+
+/**
+ * Parse the cognitive checkpoint from formation log tail.
+ * Looks for the structured verdict block that prompt.js instructs agents to emit.
+ * @param {string} logContent - tail of the formation log
+ * @returns {{ preCode: string|null, postCode: string|null }}
+ */
+function parseCognitiveCheckpoint(logContent) {
+  const result = { preCode: null, postCode: null };
+
+  // Look for the "Cognitive Checkpoint" block. TASK_1786 (DEFECT-E): the `##`
+  // markdown prefix is optional. Root cause: logger.js strips markdown headings
+  // from assistant text (`^#{1,6}\s+` → '') and prefixes each line with
+  // `[HH:MM:SS][Agent] `, so bifrost/codex logs render the header as
+  // `[19:14:09][Agent] Cognitive Checkpoint`. Claude logs only ever matched via
+  // the `[RESULT]` block (`  ## Cognitive Checkpoint`, headings preserved) —
+  // codex relay emits no result text, so that path never exists for bifrost.
+  // Matcher is strictly additive — two alternatives, so nothing that parsed
+  // before can stop parsing:
+  //   (a) the original literal `## Cognitive Checkpoint` anywhere, unchanged.
+  //       Load-bearing for headers that are not line-initial, e.g.
+  //       `<result>## Cognitive Checkpoint` in Ansuz snapshot logs.
+  //   (b) the bifrost/codex form: line-initial, optional `[..]` log-prefix
+  //       tokens, no `##`; the header must end its line so that prose mentions
+  //       of the phrase don't match.
+  const checkpointMatch = logContent.match(/(?:## Cognitive Checkpoint|(?:^|\n)[ \t]*(?:\[[^\]\n]*\])*[ \t]*Cognitive Checkpoint[ \t]*\r?(?=\n|$))[\s\S]*?(?=\n## |\n={3,}|$)/i);
+  if (!checkpointMatch) return result;
+
+  const block = checkpointMatch[0];
+
+  // Pre-code verdict: "Pre-code: RECALLED — ..." or "Pre-code: SKIP — ..."
+  const preMatch = block.match(/Pre-code:\s*(RECALLED|SKIP)\s*[—\-]\s*(.+)/i);
+  if (preMatch) {
+    result.preCode = preMatch[1].toUpperCase();
+  }
+
+  // Post-code verdict: "Post-code: INSCRIBED — ..." or "Post-code: SKIP — ..."
+  const postMatch = block.match(/Post-code:\s*(INSCRIBED|SKIP)\s*[—\-]\s*(.+)/i);
+  if (postMatch) {
+    result.postCode = postMatch[1].toUpperCase();
+  }
+
+  return result;
+}
+
+/**
+ * Detect cognitive checkpoint in formation log and return status.
+ * @param {string} taskId
+ * @param {string} [logPath] - direct log path (from caller)
+ * @param {string} [projectPath]
+ * @returns {{ checked: boolean, preCode: string|null, postCode: string|null, warnings: string[] }}
+ */
+function detectCognitiveCheckpoint(taskId, logPath, projectPath) {
+  const warnings = [];
+  const resolvedPath = logPath || findLogForTask(taskId, projectPath);
+
+  if (!resolvedPath || !fs.existsSync(resolvedPath)) {
+    return { checked: false, preCode: null, postCode: null, warnings: ['Log file not found — cognitive check skipped'] };
+  }
+
+  // Read tail (last 4KB should be enough for the checkpoint block)
+  let tail = '';
+  try {
+    const stat = fs.statSync(resolvedPath);
+    const readSize = Math.min(stat.size, 4096);
+    const buf = Buffer.alloc(readSize);
+    const fd = fs.openSync(resolvedPath, 'r');
+    fs.readSync(fd, buf, 0, readSize, Math.max(0, stat.size - readSize));
+    fs.closeSync(fd);
+    tail = buf.toString('utf-8');
+  } catch {
+    return { checked: false, preCode: null, postCode: null, warnings: ['Failed to read log file'] };
+  }
+
+  const checkpoint = parseCognitiveCheckpoint(tail);
+
+  if (!checkpoint.preCode) {
+    warnings.push('⚠️  Missing Pre-code verdict (RECALLED/SKIP) in Cognitive Checkpoint');
+  }
+  if (!checkpoint.postCode) {
+    warnings.push('⚠️  Missing Post-code verdict (INSCRIBED/SKIP) in Cognitive Checkpoint');
+  }
+
+  return {
+    checked: true,
+    preCode: checkpoint.preCode,
+    postCode: checkpoint.postCode,
+    warnings,
+  };
+}
+
+
+/**
+ * Collect thinking_tags for a task from .kenaz/specialist/thinking_log.jsonl.
+ * Returns array of unique tags, preserving first-seen order. Truncates to top 3.
+ * @param {string} taskId
+ * @param {string} projectRoot
+ * @returns {{ tags: string[], truncated: boolean, totalRaw: number }}
+ */
+function collectThinkingTags(taskId, projectRoot) {
+  const logPath = path.join(projectRoot, '.kenaz', 'specialist', 'thinking_log.jsonl');
+  if (!fs.existsSync(logPath)) return { tags: [], truncated: false, totalRaw: 0 };
+
+  const seen = new Set();
+  const ordered = [];
+  try {
+    const raw = fs.readFileSync(logPath, 'utf8');
+    for (const line of raw.split(/\r?\n/)) {
+      if (!line.trim()) continue;
+      let entry;
+      try { entry = JSON.parse(line); } catch { continue; }
+      if (entry.task_id !== taskId) continue;
+      if (!Array.isArray(entry.tags)) continue;
+      for (const t of entry.tags) {
+        if (typeof t !== 'string' || !t) continue;
+        if (seen.has(t)) continue;
+        seen.add(t);
+        ordered.push(t);
+      }
+    }
+  } catch { return { tags: [], truncated: false, totalRaw: 0 }; }
+
+  const totalRaw = ordered.length;
+  const truncated = totalRaw > 3;
+  return { tags: ordered.slice(0, 3), truncated, totalRaw };
+}
+
+/**
+ * Passive Rune Extraction: mine knowledge from git commit messages.
+ * Background bounded batch: callers may await its result; no retries.
+ * Called after a successful commit (gitResult.committed === true).
+ *
+ * Behavior:
+ *   1. Parse commit type from message prefix (fix/feat/refactor)
+ *   2. Get changed file list via git diff HEAD~1 HEAD
+ *   3. Call synapse_inscribe for each file (max 20) via MCP HTTP
+ *
+ * @param {string} commitMsg  - full commit message
+ * @param {string} projectRoot - absolute path to git repo root
+ * @param {string|null} projectPath - passed through to synapse_inscribe
+ */
+function triggerPassiveRuneExtraction(commitMsg, projectRoot, projectPath) {
+  // 1. Parse commit type
+  const typeMatch = commitMsg.match(/^(fix!?|feat!?|refactor)/i);
+  let runeType, contentPrefix;
+  if (typeMatch) {
+    const t = typeMatch[1].toLowerCase();
+    if (t.startsWith('fix')) {
+      runeType = 'risk';
+      contentPrefix = 'Fixed';
+    } else if (t.startsWith('feat')) {
+      runeType = 'summary';
+      contentPrefix = 'Added';
+    } else {
+      runeType = 'decision';
+      contentPrefix = 'Refactored';
+    }
+  } else {
+    runeType = 'summary';
+    contentPrefix = 'Added';
+  }
+
+  // 2. Get changed files (post-commit diff)
+  const changedFiles = getPostCompleteChangedFiles(projectRoot, null).slice(0, 20);
+
+  if (changedFiles.length === 0) return;
+
+  // One bounded batch; completion counts are acknowledgements, never requests fired.
+  const { inscribeBatch } = require('./bounded-http');
+  const runeContent = `${contentPrefix}: ${stripCJK(commitMsg)}`;
+  const items = changedFiles.map(filePath => ({
+    symbol_id: filePath, type: runeType, content: runeContent, confidence: 0.65,
+    // TASK_2025: synapse_inscribe is a write tool -- must not omit projectPath
+    // (mcp.rs resolve_project_for_write no longer falls back to the
+    // Dashboard's currently-selected project). Fall back to ROOT (this
+    // script's own core project) rather than dropping the param.
+    projectPath: projectPath || ROOT,
+  }));
+  return inscribeBatch(items).then(counts => {
+    console.log(`   [Rune extraction] successful=${counts.successful}, spooled=${counts.spooled}, failed=${counts.failed}, skipped=${counts.skipped} (${runeType}${counts.reason ? '; ' + counts.reason : ''}; failed writes are unconfirmed)`);
+    return counts;
+  }).catch(() => {
+    console.warn('   [Rune extraction] batch failed; completion not confirmed');
+    return null;
+  });
+}
+
+// TASK_2341: Cognitive Attribution (POST /api/synapse/link-cognitive -> COGNITIVE_APPLIES_TO graph
+// edges) was removed with the Kuzu graph; the route no longer exists.
+
+// ─────────────────────────────────────────
+// Hippocampus Episode Integration
+// ─────────────────────────────────────────
+
+/**
+ * Call a hippocampus MCP tool synchronously via the Dashboard HTTP endpoint.
+ * Uses the same spawnSync pattern as measureHealthScoreSync.
+ * Returns parsed JSON result, or null if the dashboard is not running / timed out.
+ * @param {string} toolName - e.g. 'hippocampus_episode_start' | 'hippocampus_episode_close'
+ * @param {object} toolArgs - arguments forwarded to the tool
+ * @returns {object|null}
+ */
+function callHippocampusMcpSync(toolName, toolArgs) {
+  const script = [
+    "const http = require('http');",
+    `const payload = JSON.stringify({ jsonrpc: '2.0', id: 'hipp-sync-' + Date.now(), method: 'tools/call',`,
+    `  params: { name: ${JSON.stringify(toolName)}, arguments: ${JSON.stringify(toolArgs)} } });`,
+    "const req = http.request({ hostname: '127.0.0.1', port: 18080, path: '/api/mcp',",
+    "  method: 'POST',",
+    "  headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },",
+    "  timeout: 8000 }, (res) => {",
+    "  let b = '';",
+    "  res.on('data', c => b += c);",
+    "  res.on('end', () => {",
+    "    try {",
+    "      const r = JSON.parse(b);",
+    "      const t = r && r.result && r.result.content && r.result.content[0] && r.result.content[0].text;",
+    "      if (t) { process.stdout.write(t); }",
+    "    } catch(e) { process.stderr.write(e.message); }",
+    "  });",
+    "});",
+    "req.on('error', () => {});",
+    "req.on('timeout', () => req.destroy());",
+    "req.write(payload);",
+    "req.end();",
+  ].join('\n');
+
+  try {
+    const res = spawnSync(process.execPath, ['-e', script], {
+      encoding: 'utf8',
+      timeout: 12000,
+      windowsHide: true,
+    });
+    if (res.stdout && res.stdout.trim()) {
+      try { return JSON.parse(res.stdout.trim()); } catch { return { raw: res.stdout.trim() }; }
+    }
+  } catch { /* dashboard not running or timeout — graceful degradation */ }
+  return null;
+}
+
+module.exports = {
+  initCognitive,
+  parseCognitiveCheckpoint,
+  detectCognitiveCheckpoint,
+  collectThinkingTags,
+  triggerPassiveRuneExtraction,
+  callHippocampusMcpSync,
+};