kenaz 0.3.11 → 0.3.13

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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 /**
- * Dispatch-agent model for a project, without the Dashboard (`kenaz model`).
+ * Dispatch-agent model for a project, without the Dashboard (`kenaz subagent`).
  * Reads and writes <project>/.kenaz/dashboard-models.json (dispatchModel, dispatchModelByRigor),
  * the same file and resolution dispatch.js uses; the core's copy is only a read fallback.
  * The specialist (Ansuz) runs in the user's own Claude Code / Codex session: its model is that
@@ -15,6 +15,7 @@ const fs = require('fs');
 const path = require('path');
 const { ROOT, readDashboardModels } = require('./utils');
 const { resolveDispatchModelForRigor, translateModelForAgentTool } = require('./dispatch');
+const { parseExecutorModel } = require('../bifrost/exec');
 
 const RIGORS = ['low', 'medium', 'high'];
 const fileOf = (dir) => path.join(dir, '.kenaz', 'dashboard-models.json');
@@ -32,8 +33,10 @@ function describe(projectPath) {
   const family = (models && models.dispatchFamily) || 'claude';
   const rows = RIGORS.map((rigor) => {
     const r = resolveDispatchModelForRigor({ rigor, models, cliDispatchModel: null });
-    const agent = family === 'bifrost' ? null : translateModelForAgentTool(r.rawModel).model;
-    return { rigor, model: r.rawModel, source: r.label, agentModel: agent };
+    let executor = null;
+    try { executor = parseExecutorModel(r.rawModel); } catch { /* shown as-is; dispatch.js refuses it */ }
+    const agent = family === 'bifrost' || executor || /^\w+:/.test(r.rawModel) ? null : translateModelForAgentTool(r.rawModel).model;
+    return { rigor, model: r.rawModel, source: r.label, agentModel: agent, executor: executor ? executor.adapter : null };
   });
   return { file, family, rows };
 }
@@ -45,9 +48,11 @@ function setModel(projectPath, modelId, rigor = null) {
   const id = modelId == null ? null : String(modelId).trim();
   if (id !== null) {
     if (!id) throw new Error('model id is empty');
+    // codex:<id> / deepseek:<model> run through .formation/bifrost/exec.js (throws, listing the valid ids, if invalid).
+    const executor = parseExecutorModel(id);
     // Same rule dispatch.js enforces at dispatch time: a Claude id must map onto the Agent tool enum.
-    if ((cur.dispatchFamily || 'claude') !== 'bifrost' && !translateModelForAgentTool(id).model) {
-      throw new Error(`'${id}' is not a Claude model id the Agent tool can run (expected claude-<opus|sonnet|haiku|fable>-..., or opus|sonnet|haiku|fable)`);
+    if (!executor && (cur.dispatchFamily || 'claude') !== 'bifrost' && !translateModelForAgentTool(id).model) {
+      throw new Error(`'${id}' is not a Claude model id the Agent tool can run (expected claude-<opus|sonnet|haiku|fable>-..., or opus|sonnet|haiku|fable; or codex:<id> / deepseek:<model>)`);
     }
   }
   const next = { ...cur };
@@ -66,25 +71,25 @@ function setModel(projectPath, modelId, rigor = null) {
 
 function render(d) {
   const lines = [`dispatch model (${d.file ? d.file : 'no dashboard-models.json; built-in default'})`];
-  for (const r of d.rows) lines.push(`  ${r.rigor.padEnd(6)} ${r.model}${r.agentModel ? ` -> Agent ${r.agentModel}` : ''}  [${r.source}]`);
+  for (const r of d.rows) lines.push(`  ${r.rigor.padEnd(6)} ${r.model}${r.agentModel ? ` -> Agent ${r.agentModel}` : ''}${r.executor ? ` -> executor ${r.executor} (bifrost/exec.js)` : ''}  [${r.source}]`);
   lines.push('specialist (Ansuz): the model of your Claude Code / Codex session (/model)');
   return lines.join('\n');
 }
 
-/** CLI entry shared with `kenaz model`. Returns an exit code. */
+/** CLI entry shared with `kenaz subagent`. Returns an exit code. */
 function main(argv, out = console.log, cwd = process.cwd()) {
   const val = (k) => { const i = argv.indexOf('--' + k); return i >= 0 ? argv[i + 1] : undefined; };
   const projectPath = path.resolve(val('project-path') || cwd);
   const pos = argv.filter((a, i) => !a.startsWith('--') && !['--rigor', '--project-path'].includes(argv[i - 1]));
   try {
     if (pos[0] === 'set') {
-      if (!pos[1]) { out('usage: kenaz model set <model-id> [--rigor low|medium|high]'); return 2; }
+      if (!pos[1]) { out('usage: kenaz subagent set <model-id> [--rigor low|medium|high]'); return 2; }
       out(`wrote ${setModel(projectPath, pos[1], val('rigor') || null)}`);
     } else if (pos[0] === 'unset') out(`wrote ${setModel(projectPath, null, val('rigor') || null)}`);
-    else if (pos[0]) { out('usage: kenaz model [set <model-id> | unset] [--rigor low|medium|high] [--project-path <dir>]'); return 2; }
+    else if (pos[0]) { out('usage: kenaz subagent [set <model-id> | unset] [--rigor low|medium|high] [--project-path <dir>]'); return 2; }
     out(render(describe(projectPath)));
     return 0;
-  } catch (e) { out('kenaz model: ' + e.message); return 1; }
+  } catch (e) { out('kenaz subagent: ' + e.message); return 1; }
 }
 
 if (require.main === module) process.exit(main(process.argv.slice(2)));

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

@@ -39,7 +39,7 @@ const {
 // getSubagentDispatchParams during evaluation, so a later `const` would be in
 // its temporal dead zone at call time.)
 const AGENT_TOOL_MODEL_ENUM = ['sonnet', 'opus', 'haiku', 'fable'];
-// Used when no dashboard-models.json sets dispatchModel (set one with `kenaz model set <id>`).
+// Used when no dashboard-models.json sets dispatchModel (set one with `kenaz subagent set <id>`).
 const DEFAULT_DISPATCH_MODEL = 'claude-sonnet-5-5';
 
 /**
@@ -1016,22 +1016,34 @@ async function getSubagentDispatchParams(options) {
   // 2b: a rejected dispatch must never acquire locks it won't use).
   const resolution = resolveDispatchModelForRigor({ rigor, models, cliDispatchModel: dispatchModelOverride });
   const rawModel = resolution.rawModel;
+  // TASK_2422: codex:<id> / deepseek:<model> run via .formation/bifrost/exec.js, not the Agent tool.
+  let exec = null;
+  if (!isCodex) {
+    try { exec = require('../bifrost/exec').parseExecutorModel(rawModel); } catch (e) {
+      console.error(`❌ ${resolution.label} '${rawModel}': ${e.message}`);
+      return null;
+    }
+    if (exec && exec.adapter === 'deepseek' && !dryRun && !require('../bifrost/exec').deepseekKey()) {
+      console.error('❌ deepseek executor: no API key (set DEEPSEEK_API_KEY or deepseek_api_key in ~/.kenaz/credentials.yaml)');
+      return null;
+    }
+  }
   // TASK_2315: Codex inherits the session model — nothing to translate or pass.
-  const translated = isCodex ? { model: null, lossless: true } : translateModelForAgentTool(rawModel);
-  if (!isCodex && !translated.model) {
+  const translated = isCodex || exec ? { model: null, lossless: true } : translateModelForAgentTool(rawModel);
+  if (!isCodex && !exec && !translated.model) {
     console.error(`❌ ${resolution.label} '${rawModel}' cannot be mapped to an Agent tool model family (${AGENT_TOOL_MODEL_ENUM.join('|')}) — refusing to silently guess a substitute model. Fix the model selection (Quick Actions → Default Models).`);
     return null;
   }
   const dispatchModel = translated.model;
   const modelTranslation = isCodex
     ? { requested: rawModel, inherited: true }
-    : { requested: rawModel, agentToolModel: dispatchModel, granularityLoss: !translated.lossless };
+    : exec ? { requested: rawModel, executor: exec.adapter } : { requested: rawModel, agentToolModel: dispatchModel, granularityLoss: !translated.lossless };
   if (!translated.lossless) {
     process.stderr.write(`[dispatch] model '${rawModel}' → Agent tool family '${dispatchModel}' — the Agent tool only expresses family names (${AGENT_TOOL_MODEL_ENUM.join('|')}); version/speed selections (e.g. 5 vs 4.x, [1m]) are NOT expressible on the subagent path. If the exact version matters, choose a model whose family the Agent tool can express.\n`);
   }
   // TASK_1998 R3 (+ two-axis policy): the resolved choice, always printed
   // (unlike the granularity block above, which only fires on lossy translation).
-  process.stderr.write(`[dispatch] rigor=${resolution.rigorKey} complexity=${complexity} model=${rawModel} → ${isCodex ? 'inherited by Codex session' : "family '" + dispatchModel + "'"} (source: ${resolution.source})\n`);
+  process.stderr.write(`[dispatch] rigor=${resolution.rigorKey} complexity=${complexity} model=${rawModel} → ${isCodex ? 'inherited by Codex session' : exec ? 'executor ' + exec.adapter + ' (bifrost/exec.js)' : "family '" + dispatchModel + "'"} (source: ${resolution.source})\n`);
 
   // TASK_2362: subagent is the only route. dispatchMode is a legacy config echo:
   // missing -> 'subagent'; 'subagent'|'auto' accepted; 'formation' (retired) or
@@ -1101,8 +1113,9 @@ async function getSubagentDispatchParams(options) {
   // TASK_2315: Codex has no harness-managed worktree isolation — always pre-create
   // one (same-project included) and hand its path to the agent as cwd.
   const wtRepo2315 = projectPath || ROOT;
-  if (isCodex && iso.mode === 'agent_tool_worktree') { iso.mode = 'target_repo_worktree'; iso.source = 'codex-harness'; }
-  const isCrossProject = iso.isCrossProject || (isCodex && iso.mode === 'target_repo_worktree');
+  // TASK_2422: executors (codex:/deepseek:) have no harness worktree either.
+  if ((isCodex || exec) && iso.mode === 'agent_tool_worktree') { iso.mode = 'target_repo_worktree'; iso.source = isCodex ? 'codex-harness' : 'executor'; }
+  const isCrossProject = iso.isCrossProject || ((isCodex || exec) && iso.mode === 'target_repo_worktree');
   let crossWorktree = null; // { worktreePath, branchName } when mode=target_repo_worktree
   let serialLock = null;    // { lockFile } when mode=serial_lock
   let worktreeFallbackReason = null; // TASK_2067: non-null only on a genuine target_repo_worktree creation failure that degraded to serial_lock -- rides in the isolation payload, not just stderr
@@ -1139,6 +1152,13 @@ async function getSubagentDispatchParams(options) {
     }
   }
 
+  if (exec && iso.mode !== 'target_repo_worktree') {
+    console.error(`❌ executor ${exec.adapter} needs a git worktree for the card (isolation mode '${iso.mode}'${worktreeFallbackReason ? ': ' + worktreeFallbackReason : ''}) — refusing to run a non-Claude agent in a shared tree`);
+    releaseResourceLocks(_saAcquiredResources, _saRoot);
+    releaseAdoptedClaimMarker(_saClaim);
+    return null;
+  }
+
   if (iso.mode === 'serial_lock' && dryRun) {
     console.error('   [dry-run] shared-tree dispatch lock NOT acquired: ' + dispatchLockPath(projectPath));
   } else if (iso.mode === 'serial_lock') {
@@ -1254,7 +1274,7 @@ async function getSubagentDispatchParams(options) {
   // Still true: the description field does not affect the worktree name, and per-TASK
   // naming (task_<taskid>) requires the formation path via
   // formations.setupUnitWorktree({ taskId }).
-  const agentParams = isCodex ? undefined : {
+  const agentParams = isCodex || exec ? undefined : {
     // Include taskInput so the Agent tool description is unique per task (helps tracing)
     description: `[${taskInput}] Kenaz subagent (${skill})`,
     model: dispatchModel,
@@ -1315,7 +1335,7 @@ async function getSubagentDispatchParams(options) {
   // by dashboard vs dashboard-by-rigor vs cli without re-deriving it.
   // Two-axis policy: complexity rides along too, so dispatch-stats.js can
   // group by (rigor, complexity) instead of rigor alone.
-  if (!dryRun) appendDispatchPromptStats({ taskId: taskInput, rigor: resolution.rigorKey, complexity, formation, promptText, model: dispatchModel, modelSource: resolution.source, projectPath });
+  if (!dryRun) appendDispatchPromptStats({ taskId: taskInput, rigor: resolution.rigorKey, complexity, formation, promptText, model: dispatchModel || rawModel, modelSource: resolution.source, projectPath });
 
   // TASK_2032: mirror headless.js's formation-path auto-activation (~L272-290)
   // on the subagent path — every gate/guard above has passed and this function
@@ -1355,10 +1375,26 @@ async function getSubagentDispatchParams(options) {
   // on agentParams itself). rigor is the NORMALIZED key (null/unrecognized →
   // 'medium') that actually drove model resolution, not the raw card field.
   // complexity is likewise the normalized CONTEXT-volume key.
+  // TASK_2422: executor block = the card's worktree + one command for Ansuz to run with Bash run_in_background.
+  // The prompt goes to exec.js as a file (never argv); no secret is ever part of this payload.
+  let executor;
+  if (exec) {
+    const dir = path.join(require('os').tmpdir(), 'kenaz-exec');
+    const stem = path.join(dir, `${(taskInput || 'adhoc').replace(/[^\w.-]/g, '_')}-${Date.now().toString(36)}`);
+    const promptFile = stem + '.prompt.md'; const resultFile = stem + '.result.json';
+    if (!dryRun) { fs.mkdirSync(dir, { recursive: true }); fs.writeFileSync(promptFile, promptText); }
+    const q = (s) => '"' + String(s).replace(/"/g, '\\"') + '"';
+    executor = {
+      adapter: exec.adapter, model: exec.id, worktreePath: crossWorktree.worktreePath, branchName: crossWorktree.branchName,
+      promptFile, resultFile,
+      command: `node ${q(path.join(__dirname, '..', 'bifrost', 'exec.js'))} --adapter=${exec.adapter} --model=${q(exec.id)} --worktree ${q(crossWorktree.worktreePath)} --prompt-file ${q(promptFile)} --result-file ${q(resultFile)}`,
+      note: 'Run command with Bash run_in_background, wait for the completion notice, read resultFile (ok, exitCode, lastMessage, commits), then verify and merge the branch as for an Agent subagent.',
+    };
+  }
   return {
     promptText, taskId: taskInput, formation, skill, dispatchMode, effectiveMode: 'subagent',
     ...(isCodex ? { harness: 'codex', cwd: crossWorktree ? crossWorktree.worktreePath : null, worktreePath: crossWorktree ? crossWorktree.worktreePath : null } : {}),
-    modelTranslation, isolation, ...(agentParams ? { agentParams } : {}), rigor: resolution.rigorKey, complexity, modelSource: resolution.source,
+    modelTranslation, isolation, ...(agentParams ? { agentParams } : {}), ...(executor ? { executor } : {}), rigor: resolution.rigorKey, complexity, modelSource: resolution.source,
     ...(dryRun ? { dryRun: true } : {}),
   };
 }

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

@@ -7,6 +7,7 @@
  *   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)
+ *   5. lessons         <project>/.kenaz/knowledge and ~/.kenaz/knowledge (active, fires, recurrences, graduated / merged / archived)
  */
 const fs = require('fs');
 const os = require('os');
@@ -76,36 +77,36 @@ 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) {
+function readCommits(repo, sinceMs, untilMs) {
   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) => {
+    return git(repo, 'log', '--all', `--since=${new Date(sinceMs).toISOString()}`, ...(untilMs ? [`--until=${new Date(untilMs).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). */
+/** Shas of commits the merged branch gained after the agent's first `task completed` commit (fixes before the merge). */
 function branchFixups(repo, merges) {
-  let n = 0;
+  const shas = [];
   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));
+      const rows = git(repo, 'log', '--reverse', '--format=%H\t%s', `${m.parents[0]}..${m.parents[1]}`).split('\n').filter(Boolean).map((l) => l.split('\t'));
+      const first = rows.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;
+      if (first >= 0) shas.push(...rows.slice(first + 1).filter(([, s]) => !/task completed\s*$/i.test(s)).map(([h]) => h));
     } catch (_) { /* unreadable merge: not judged */ }
   }
-  return n;
+  return shas;
 }
 
-function dispatchStats({ repo, now, days }) {
+function dispatchStats({ repo, now, days, until }) {
   const src = 'git log of ' + repo + ' (`Merge TASK_n` commits, `[TASK_n]` commits)';
-  const commits = readCommits(repo, now - days * DAY);
+  const commits = readCommits(repo, now - days * DAY, until);
   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); };
@@ -126,14 +127,15 @@ function dispatchStats({ repo, now, days }) {
     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` });
+    // `shas`: the extra commits made after delivery (TASK_2427 harvest reads the files they touched)
+    if (c.merges.length > 1) rework.push({ card: `TASK_${n}`, why: `re-dispatched/merged ${c.merges.length} times`, shas: [] });
+    else if (abandoned) rework.push({ card: `TASK_${n}`, why: `${abandoned} agent delivery commit(s) never merged (re-dispatch or a losing A/B arm)`, shas: c.work.filter((x) => !x.onHead).map((x) => x.sha) });
+    else if (fixedOnBranch.length) rework.push({ card: `TASK_${n}`, why: `${fixedOnBranch.length} commit(s) on the branch after the agent's delivery, before the merge`, shas: fixedOnBranch });
+    else if (after.length) rework.push({ card: `TASK_${n}`, why: `${after.length} fix-up commit(s) on the main line after the merge`, shas: after.map((x) => x.sha) });
   }
   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),
+    firstPassRate: merged.length ? (merged.length - rework.length) / merged.length : null, rework, mergedCards: merged, 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)',
   };
 }
@@ -200,6 +202,24 @@ function alayaStats({ home, now, days }) {
   };
 }
 
+function lessonStats({ home, cwd, now, days }) {
+  const src = '<project>/.kenaz/knowledge + ~/.kenaz/knowledge (+ archive/, .usage.jsonl, memory_usage.jsonl)';
+  try {
+    return { source: src, ...require('../../.specialist/tools/lessons.js').stats({ projectPath: cwd, home, now, days }) };
+  } catch (e) { return { source: src, note: `${NO_DATA} (${e.message})` }; }
+}
+
+function selfImprovementStats({ home, cwd, now, days }) {
+  const src = '<project>/.kenaz/specialist/correction-nudges.jsonl + lessons + .kenaz/knowledge/.harvested.json + git (this window vs the previous one)';
+  try {
+    const cur = dispatchStats({ repo: cwd, now, days });
+    const prev = dispatchStats({ repo: cwd, now: now - days * DAY, days, until: now - days * DAY });
+    const pick = (d) => (d.firstPassRate == null ? null : { rate: d.firstPassRate, merged: d.merged });
+    return { source: src, ...require('../../.specialist/tools/lessons-harvest.js').selfStats({ projectPath: cwd, home, now, days }),
+      firstPass: { window: pick(cur), previous: pick(prev) } };
+  } catch (e) { return { source: src, note: `${NO_DATA} (${e.message})` }; }
+}
+
 function collect({ home = os.homedir(), cwd = process.cwd(), days = 14, now = Date.now() } = {}) {
   return {
     days,
@@ -207,6 +227,8 @@ function collect({ home = os.homedir(), cwd = process.cwd(), days = 14, now = Da
     dispatch: dispatchStats({ repo: cwd, now, days }),
     fieldReports: fieldStats({ home, repo: cwd, now, days }),
     alaya: alayaStats({ home, now, days }),
+    lessons: lessonStats({ home, cwd, now, days }),
+    selfImprovement: selfImprovementStats({ home, cwd, now, days }),
   };
 }
 
@@ -243,6 +265,25 @@ function render(s) {
       `  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}`);
   }
+  const le = s.lessons || { source: '-', note: 'no data' };
+  L.push('', 'Lessons', `  source: ${le.source}`);
+  if (!le.project) L.push(`  ${le.note}`);
+  else for (const k of ['project', 'user']) {
+    const x = le[k];
+    L.push(`  ${k}: active ${x.active}, fires in window ${x.fires}, recurrences ${x.recurrences}; graduated ${x.graduated}, merged ${x.merged}, archived ${x.archived}`);
+  }
+  const si = s.selfImprovement;
+  if (si) {
+    L.push('', 'Self-improvement', `  source: ${si.source}`);
+    if (si.nudges == null) L.push(`  ${si.note}`);
+    else {
+      const r = (x) => (x ? `${(x.rate * 100).toFixed(0)}% of ${x.merged}` : NO_DATA);
+      L.push(`  correction nudges ${si.nudges}: lesson recorded within 15 min after ${si.converted}${si.nudges ? ` (${(100 * si.converted / si.nudges).toFixed(0)}%)` : ''}`,
+        `  lessons by source: ${Object.entries(si.bySource).map(([k, v]) => `${k}=${v.lessons} (fired ${v.fired}, recurred before first fire ${v.recurBefore}, after ${v.recurAfter})`).join('; ') || 'none'}`,
+        `  graduated ${si.graduated}; harvest items open ${si.harvestOpen}, recorded ${si.harvestRecorded}`,
+        `  first-pass merge rate: this window ${r(si.firstPass.window)}, previous window ${r(si.firstPass.previous)}`);
+    }
+  }
   return L.join('\n');
 }
 
@@ -256,4 +297,4 @@ function main(argv, out = console.log, opts = {}) {
 }
 
 if (require.main === module) process.exit(main(process.argv.slice(2)));
-module.exports = { main, collect, peerStats, dispatchStats, fieldStats, alayaStats, render };
+module.exports = { main, collect, peerStats, dispatchStats, git, fieldStats, alayaStats, render };

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

@@ -164,10 +164,10 @@ test('alaya: bija counts, activations, exported and seed imports in window; miss
 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']);
+  assert.deepStrictEqual(Object.keys(JSON.parse(lines[0])), ['days', 'peer', 'dispatch', 'fieldReports', 'alaya', 'lessons', 'selfImprovement']);
   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);
+  for (const h of ['Peer delivery', 'Dispatch first-pass merge rate', 'Field report -> release latency', 'Alaya', 'Lessons', 'Self-improvement']) 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);
 });

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