kenaz 0.3.10 → 0.3.12

package/core/.formation/bifrost/shared/consolidate.js

@@ -131,51 +131,6 @@ function extractEpisodeFromTranscript(filePath){
   }
 }
 
-// archiveEpisodeToHippocampus: create+append+close hippocampus episode via MCP HTTP.
-// fail-open: any failure returns false without throwing.
-// hippocampus_episode_append REQUIRES phase (entry_type is not a valid param — server
-// rejects with isError and the episode closes empty). projectPath must be explicit:
-// the MCP HTTP layer is stateless and defaults to the dashboard's current project.
-async function archiveEpisodeToHippocampus(port,opts,extracted){
-  try{
-    var root=resolveRoot(opts);
-    var scope='Bifrost Codex session'+(opts.sessionId?' '+opts.sessionId:'');
-    var tags=['bifrost','codex','session_memory'];
-    var startRes=await mcpCall(port,'hippocampus_episode_start',{
-      scope:scope,
-      tags:tags,
-      source:'bifrost_codex',
-      projectPath:root
-    });
-    var startParsed=mcpToolJson(startRes);
-    if(!startParsed)return false;
-    var epId=startParsed.episode_id||startParsed.id;
-    if(!epId)return false;
-    var content=extracted?extracted.summary:'Codex session ended (no transcript).';
-    var ap1=await mcpCall(port,'hippocampus_episode_append',{
-      episode_id:epId,
-      content:content,
-      phase:'summary',
-      projectPath:root
-    });
-    if(!mcpToolJson(ap1))process.stderr.write('[bifrost:consolidate] episode append (summary) failed\n');
-    if(extracted&&extracted.runeHints&&extracted.runeHints.length){
-      var ap2=await mcpCall(port,'hippocampus_episode_append',{
-        episode_id:epId,
-        content:'Rune candidates: '+extracted.runeHints.join('; '),
-        phase:'observation',
-        projectPath:root
-      });
-      if(!mcpToolJson(ap2))process.stderr.write('[bifrost:consolidate] episode append (observation) failed\n');
-    }
-    await mcpCall(port,'hippocampus_episode_close',{episode_id:epId,projectPath:root});
-    return true;
-  }catch(e){
-    process.stderr.write('[bifrost:consolidate] hippocampus archive error: '+e.message+'\n');
-    return false;
-  }
-}
-
 // writeHandoff: write ISBAR handoff JSON to the per-session slot (TASK_1829).
 // Last-writer-wins within a session's own slot only; other sessions' slots are
 // untouched (per-session isolation replaced the old shared singular slot).
@@ -205,7 +160,7 @@ function writeHandoff(root,opts,extracted){
           status:'session_ended'
         },
         background:{
-          context:'Codex session ended via Stop hook. Transcript tee and episode archived.',
+          context:'Codex session ended via Stop hook. Transcript tee archived.',
           turn_count:extracted?extracted.turnCount:0
         },
         assessment:{
@@ -259,10 +214,6 @@ async function runStopConsolidation(opts){
     else if(tee&&typeof tee.close==='function')tee.close();
     var extracted=null;
     try{extracted=extractEpisodeFromTranscript(transcriptPath);}catch(ee){}
-    // Episode archive (fail-open)
-    var epOk=false;
-    try{epOk=await archiveEpisodeToHippocampus(port,opts||{},extracted);}catch(ae){}
-    if(!epOk){process.stderr.write('[bifrost:consolidate] hippocampus unavailable or error -- skipping episode.\n');}
     // Handoff (fail-open)
     try{writeHandoff(root,opts||{},extracted);}catch(he){}
     // Heartbeat (fail-open)
@@ -279,7 +230,6 @@ module.exports={
   mcpCall:mcpCall,
   mcpToolJson:mcpToolJson,
   extractEpisodeFromTranscript:extractEpisodeFromTranscript,
-  archiveEpisodeToHippocampus:archiveEpisodeToHippocampus,
   writeHandoff:writeHandoff,
   appendHeartbeat:appendHeartbeat,
   runStopConsolidation:runStopConsolidation

package/core/.formation/bifrost/sync.js

@@ -57,15 +57,15 @@ function translate(content) {
   // 4. Replace ToolSearch references (Codex doesn't have this)
   result = result.replace(
     /用 `ToolSearch "synapse"` 偵測/g,
-    '嘗試呼叫 synapse_status 偵測'
+    '嘗試呼叫 kenaz_ping 偵測'
   );
   result = result.replace(
     /ToolSearch 未找到 → 該 session 全程降級用 Grep\/Glob/g,
-    'synapse_status 失敗 → 該 session 全程降級用 shell 命令搜尋'
+    'kenaz_ping 失敗 → 該 session 全程降級用 shell 命令搜尋'
   );
 
   // 5. Replace Claude Code MCP tool name prefix
-  //    mcp__kenaz-dashboard__synapse_recall → synapse_recall (Codex uses short names)
+  //    mcp__kenaz-dashboard__kenaz_task_list → kenaz_task_list (Codex uses short names)
   result = result.replace(/mcp__kenaz-dashboard__/g, '');
 
   // 6. Replace /Ansuz, /Amelia etc. slash command references
@@ -85,7 +85,6 @@ ${renderBootstrap({ contextual: true })}
 ## Project-Path 自動解析
 
 當前工作目錄（cwd）即為專案根目錄。所有 MCP 工具呼叫的 \`projectPath\` 參數使用 cwd：
-- \`synapse_recall({ query: "...", projectPath: "<cwd>" })\`
 - \`kenaz_task_list({ projectPath: "<cwd>" })\`
 - phase-gate.js 指令加上 \`--project-path=<cwd>\`
 
@@ -97,7 +96,7 @@ ${renderBootstrap({ contextual: true })}
 
 本檔案由 Bifröst 從 CLAUDE.md 自動翻譯。以下是 Codex 特有的差異：
 
-1. **MCP 工具**：透過 \`codex mcp add kenaz-dashboard\` 連接 Dashboard（由 setup-codex.js 自動完成）。所有 Synapse/Hippocampus/Thalamus 工具可直接使用，不需要 \`mcp__kenaz-dashboard__\` 前綴。
+1. **MCP 工具**：透過 \`codex mcp add kenaz-dashboard\` 連接 Dashboard（由 setup-codex.js 自動完成）。所有 kenaz_* 工具可直接使用，不需要 \`mcp__kenaz-dashboard__\` 前綴。
 2. **檔案操作**：Codex 使用 shell 命令進行檔案操作，而非 Claude Code 的 Read/Edit/Write 工具。
 3. **互動式問題**：Codex 沒有 AskUserQuestion 工具，直接用文字詢問用戶即可。
 4. **Specialist 系統**：若需啟動 Ansuz 等 Specialist，使用 \`node .formation/bifrost/launch.js --specialist Ansuz\`（自動注入 MCP + AGENTS.override.md）。

package/core/.formation/tools/__tests__/subagent-bifrost-guard.test.js

@@ -139,7 +139,7 @@ setModels({ dispatchModel: 'claude-fable-5', dispatchFamily: 'claude', dispatchM
 }
 
 // ── [7] TASK_1815 model mapping: every emitted model is an enum member ──────
-// Covers the NATIVE ids from dashboard/src/lib/models.ts plus the missing-field
+// Covers the NATIVE ids from the retired Dashboard model list (models.ts) plus the missing-field
 // fallback ('claude-sonnet-4-6', mirrors DEFAULT_DISPATCH_MODEL) and a haiku id
 // (enum member with no dashboard source entry today — must still map).
 const MAP_CASES = [

package/core/.formation/tools/dispatch.js

@@ -49,7 +49,7 @@ const DEFAULT_DISPATCH_MODEL = 'claude-sonnet-5-5';
  * cannot express — the enum has FAMILY names only. So this translation is
  * structurally LOSSY: claude-opus-5[1m] and claude-opus-4-8[1m] both become
  * 'opus'. Callers must surface that loss, never treat it as equivalence.
- * NOTE: dashboard/src/lib/models.ts `family` ('claude'|'bifrost') is the
+ * NOTE: the retired Dashboard model list (models.ts) `family` ('claude'|'bifrost') is the
  * ADAPTER family and is unrelated to this Claude sub-family mapping.
  * @param {string} rawModel - dashboard model id, possibly with [1m]-style suffix
  * @returns {{ model: string|null, lossless: boolean }} model=null → unmappable
@@ -62,7 +62,7 @@ function translateModelForAgentTool(rawModel) {
     return { model: stripped, lossless: stripped === String(rawModel).trim() };
   }
   // claude-<family>[-version...] → <family>. Covers every NATIVE id in
-  // dashboard/src/lib/models.ts (claude-fable-5-1[1m], claude-opus-5-5[1m],
+  // the retired Dashboard model list (models.ts) (claude-fable-5-1[1m], claude-opus-5-5[1m],
   // claude-fable-5[1m], claude-opus-4-8[1m], claude-sonnet-5,
   // claude-sonnet-4-6) plus future versions of the same families. 'haiku' has
   // no dashboard source entry today but maps fine if one appears.

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

@@ -21,7 +21,7 @@ function openDb(file) {
   try {
     const { DatabaseSync } = require('node:sqlite');
     return { db: new DatabaseSync(file, { readOnly: true }) };
-  } catch (e) { return { err: `${NO_DATA} (cannot read ${file}: ${e.code === 'MODULE_NOT_FOUND' ? 'needs Node >= 22.5 for node:sqlite' : e.message})` }; }
+  } 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; } }
 

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);
-});

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

@@ -1,14 +1,12 @@
 /**
  * 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.
+ * Cognitive checkpoint detection and thinking tags. (Passive rune extraction and the
+ * Hippocampus MCP sync were removed with the memory system in TASK_2411.)
  */
 
 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'); } })();
@@ -147,124 +145,9 @@ function collectThinkingTags(taskId, projectRoot) {
   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,
 };

package/core/.formation/tools/post-complete/task2420.test.js

@@ -0,0 +1,129 @@
+/**
+ * TASK_2420 — runtime/config-only completion and truthful outcome reporting.
+ *
+ * Drives the REAL task-api.js CLI (`complete`) against a temp git repo with a temp
+ * .kenaz/tasks store. Never touches ~/.kenaz, ~/.claude or ~/.codex.
+ */
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..', '..', '..');
+const TASK_API = path.join(ROOT, '.collaboration', 'core', 'task-api.js');
+const { summarizePostComplete, spawnFailureCause } = require('../post-complete');
+
+function git(cmd, cwd) {
+  return execSync(cmd, { cwd, encoding: 'utf8', timeout: 20000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+}
+
+function setup(taskId, scopePaths = []) {
+  const tmp = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'tn2420-')));
+  const repo = path.join(tmp, 'repo');
+  fs.mkdirSync(repo);
+  git('git init -b userwork', repo);
+  git('git config user.email t@t.com', repo);
+  git('git config user.name Test', repo);
+  git('git config commit.gpgsign false', repo);
+  fs.writeFileSync(path.join(repo, 'README.md'), 'init\n');
+  fs.writeFileSync(path.join(repo, '.gitignore'), '.kenaz/\n');
+  git('git add README.md .gitignore', repo);
+  git('git commit --no-verify -m init', repo);
+  const dir = path.join(repo, '.kenaz', 'tasks', 'active');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${taskId}.yaml`), [
+    `id: "${taskId}"`, 'title: "runtime repair"', 'status: in_progress', 'priority: P2',
+    scopePaths.length ? `scope_paths:\n${scopePaths.map(p => `  - "${p}"`).join('\n')}` : 'scope_paths: []', '',
+  ].join('\n'));
+  return { tmp, repo };
+}
+
+function complete(repo, taskId, extra = []) {
+  return spawnSync('node', [TASK_API, '--project-path', repo, 'complete', taskId, '--skip-archive', ...extra], {
+    cwd: ROOT, encoding: 'utf8', timeout: 120000, windowsHide: true,
+    env: { ...process.env, KENAZ_INTEGRATION_QUEUE: '' },
+  });
+}
+
+const where = (repo, taskId) => ['done', 'active', 'blocked']
+  .filter(d => fs.existsSync(path.join(repo, '.kenaz', 'tasks', d, `${taskId}.yaml`)));
+
+test('TASK_2420: no-branch task with --no-source completes; git merge/verify reported as skipped', () => {
+  const taskId = 'TASK_24201';
+  const { tmp, repo } = setup(taskId);
+  try {
+    const r = complete(repo, taskId, ['--no-source']);
+    const out = `${r.stdout}\n${r.stderr}`;
+    assert.equal(r.status, 0, out);
+    assert.match(r.stdout, /任務已完成/);
+    assert.match(out, /no branch: nothing to integrate/);
+    assert.doesNotMatch(out, /Git merge failed/);
+    assert.deepEqual(where(repo, taskId), ['done']);
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('TASK_2420: --no-source is refused when the task branch has unmerged commits (work is not silently dropped)', () => {
+  const taskId = 'TASK_24202';
+  const { tmp, repo } = setup(taskId);
+  try {
+    git(`git checkout -b task/${taskId.toLowerCase()}`, repo);
+    fs.writeFileSync(path.join(repo, 'a.txt'), 'real work\n');
+    git('git add a.txt', repo);
+    git('git commit --no-verify -m work', repo);
+    git('git checkout userwork', repo);
+    const r = complete(repo, taskId, ['--no-source']);
+    assert.notEqual(r.status, 0, 'must not report success');
+    assert.doesNotMatch(r.stdout, /✅ 任務已完成/);
+    assert.match(r.stderr, /任務未完成/);
+    assert.match(r.stderr, /no_source_but_work_exists/);
+    assert.match(r.stderr, /exists with commits not on userwork/);
+    assert.ok(!where(repo, taskId).includes('done'), `card must not stay in done/: ${where(repo, taskId)}`);
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('TASK_2420: branch task whose merge fails is NOT reported as plain success and the cause is shown', () => {
+  const taskId = 'TASK_24203';
+  const { tmp, repo } = setup(taskId);
+  try {
+    // Conflicting edits: branch and userwork both change a.txt differently.
+    fs.writeFileSync(path.join(repo, 'a.txt'), 'base\n');
+    git('git add a.txt', repo); git('git commit --no-verify -m base', repo);
+    git(`git checkout -b task/${taskId.toLowerCase()}`, repo);
+    fs.writeFileSync(path.join(repo, 'a.txt'), 'branch side\n');
+    git('git commit --no-verify -am branch', repo);
+    git('git checkout userwork', repo);
+    fs.writeFileSync(path.join(repo, 'a.txt'), 'user side\n');
+    git('git commit --no-verify -am user', repo);
+    const r = complete(repo, taskId);
+    assert.notEqual(r.status, 0, `${r.stdout}\n${r.stderr}`);
+    assert.doesNotMatch(r.stdout, /✅ 任務已完成/);
+    assert.match(r.stderr, /任務未完成/);
+    assert.match(r.stderr, /git: failed — \S+/);
+    assert.ok(!where(repo, taskId).includes('done'), `card must not stay in done/: ${where(repo, taskId)}`);
+  } finally { fs.rmSync(tmp, { recursive: true, force: true }); }
+});
+
+test('TASK_2420: summarize — move/reconcile failures carry their real cause and card is flagged unreconciled', () => {
+  const s = summarizePostComplete({
+    git: { merged: false, taskBranch: 'task/x', failure_reason: 'merge_conflict', mergeErrorText: 'CONFLICT in a.txt', blockError: 'EBUSY: resource busy' },
+    reconcileError: 'ETIMEDOUT: spawnSync node ETIMEDOUT',
+  });
+  assert.equal(s.outcome, 'not_completed');
+  assert.equal(s.cardState, 'done_unreconciled');
+  const txt = JSON.stringify(s.steps);
+  assert.match(txt, /EBUSY: resource busy/);
+  assert.match(txt, /ETIMEDOUT/);
+  assert.match(txt, /CONFLICT in a\.txt/);
+  assert.doesNotMatch(txt, /unknown error/i);
+});
+
+test('TASK_2420: spawnFailureCause never returns "unknown error"', () => {
+  assert.match(spawnFailureCause({ status: null, stderr: '', stdout: '', error: Object.assign(new Error('spawnSync node ETIMEDOUT'), { code: 'ETIMEDOUT' }) }), /ETIMEDOUT/);
+  assert.match(spawnFailureCause({ status: null, signal: 'SIGTERM', stderr: '', stdout: '' }), /SIGTERM/);
+  assert.match(spawnFailureCause({ status: 3, stderr: '', stdout: '' }), /code 3/);
+  assert.equal(spawnFailureCause({ status: 1, stderr: 'boom\nmore' }), 'boom');
+});

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

@@ -178,19 +178,7 @@ function detectAllTestCommands(projectRoot, scopePaths = []) {
   const normScopes = (scopePaths || []).map(p => p.replace(/\\/g, '/'));
   const scopeTouches = (prefix) => normScopes.some(s => s === prefix || s.startsWith(prefix + '/') || prefix.startsWith(s + '/'));
 
-  // 1. Dashboard (dashboard/package.json) — React/TS
-  const dashPkg = path.join(projectRoot, 'dashboard', 'package.json');
-  if (fs.existsSync(dashPkg)) {
-    try {
-      const pkg = JSON.parse(fs.readFileSync(dashPkg, 'utf8'));
-      const testScript = pkg.scripts?.test;
-      if (testScript && !testScript.includes('echo "Error')) {
-        commands.push({ cmd: 'npm test -- --passWithNoTests', cwd: path.join(projectRoot, 'dashboard'), label: 'dashboard (npm test)' });
-      }
-    } catch { /* skip */ }
-  }
-
-  // 2. Root package.json
+  // 1. Root package.json
   const rootPkg = path.join(projectRoot, 'package.json');
   if (fs.existsSync(rootPkg)) {
     try {
@@ -202,7 +190,7 @@ function detectAllTestCommands(projectRoot, scopePaths = []) {
     } catch { /* skip */ }
   }
 
-  // 3. Rust: dashboard/src-tauri/ — only when scope explicitly touches it.
+  // 2. Rust: dashboard/src-tauri/ (kenaz-server lib) — only when scope explicitly touches it.
   // The cargo build pulls kuzu via cmake which is the dominant source of
   // false-positive regression failures observed in this project (~every
   // dispatch reported "src-tauri tests FAILED" with cmake exit 2). Empty
@@ -210,13 +198,7 @@ function detectAllTestCommands(projectRoot, scopePaths = []) {
   // Agents that explicitly need Rust coverage can pass --test-cmd.
   const tauriCargo = path.join(projectRoot, 'dashboard', 'src-tauri', 'Cargo.toml');
   if (fs.existsSync(tauriCargo) && scopeTouches('dashboard/src-tauri')) {
-    commands.push({ cmd: 'cargo test --bin kenaz-dashboard', cwd: path.join(projectRoot, 'dashboard', 'src-tauri'), label: 'src-tauri (cargo test)' });
-  }
-
-  // 4. Rust: dashboard/pty-server/ — same selective rule
-  const ptyCargo = path.join(projectRoot, 'dashboard', 'pty-server', 'Cargo.toml');
-  if (fs.existsSync(ptyCargo) && scopeTouches('dashboard/pty-server')) {
-    commands.push({ cmd: 'cargo test', cwd: path.join(projectRoot, 'dashboard', 'pty-server'), label: 'pty-server (cargo test)' });
+    commands.push({ cmd: 'cargo test --lib', cwd: path.join(projectRoot, 'dashboard', 'src-tauri'), label: 'src-tauri (cargo test)' });
   }
 
   // 5. Python (pytest) — root level