kenaz 0.3.12 → 0.3.13

package/core/.formation/tools/__tests__/subagent-executor.test.js

@@ -0,0 +1,198 @@
+'use strict';
+// TASK_2422: codex:/deepseek: executors. Stub `codex` and `claude` on PATH, temp dirs only
+// (never the real ~/.codex, ~/.claude, ~/.kenaz; no real codex/claude/wscript is ever started).
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { spawnSync } = require('node:child_process');
+
+const ROOT = path.resolve(__dirname, '..', '..', '..');
+const EXEC = path.join(ROOT, '.formation', 'bifrost', 'exec.js');
+const DISPATCH = path.join(ROOT, '.formation', 'tools', 'dispatch.js');
+const TASKAPI = path.join(ROOT, '.collaboration', 'core', 'task-api.js');
+const dm = require('../dispatch-model');
+const KEY = 'sk-test-DEEPSEEK-SECRET-1234567890';
+
+const tmp = (t, p) => { const d = fs.mkdtempSync(path.join(os.tmpdir(), p)); t.after(() => fs.rmSync(d, { recursive: true, force: true })); return d; };
+const git = (cwd, args) => spawnSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', ...args], { cwd, encoding: 'utf8', windowsHide: true });
+function repo(t) {
+  const d = tmp(t, 'exec-wt-');
+  fs.writeFileSync(path.join(d, 'README.md'), 'x'); git(d, ['init', '-q']); git(d, ['add', '-A']); git(d, ['commit', '-q', '--no-verify', '-m', 'init']);
+  return d;
+}
+
+// One stub script serves both binaries: records argv/env/stdin to STUB_OUT/<name>.json, optionally commits.
+const STUB_JS = `
+const fs = require('fs'), path = require('path'), cp = require('child_process');
+const name = path.basename(process.argv[1], '.js');
+let stdin = ''; process.stdin.on('data', (d) => { stdin += d; });
+process.stdin.on('end', () => {
+  const argv = process.argv.slice(2);
+  fs.writeFileSync(path.join(process.env.STUB_OUT, name + '.json'), JSON.stringify({ argv, cwd: process.cwd(), stdin,
+    env: { ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN, ANTHROPIC_MODEL: process.env.ANTHROPIC_MODEL, ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY } }));
+  if (process.env.STUB_WRITE_ONLY) fs.writeFileSync(path.join(process.cwd(), 'left.txt'), 'x'); // a sandboxed agent: edits, cannot commit
+  if (process.env.STUB_COMMIT) {
+    fs.writeFileSync(path.join(process.cwd(), 'out.txt'), 'x');
+    cp.spawnSync('git', ['add', '-A'], { cwd: process.cwd() });
+    cp.spawnSync('git', ['-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '--no-verify', '-m', 'stub work'], { cwd: process.cwd() });
+  }
+  const o = argv.indexOf('-o'); if (o >= 0) fs.writeFileSync(argv[o + 1], 'codex last message');
+  if (name === 'claude') console.log('claude says ' + (process.env.STUB_ECHO_KEY ? process.env.ANTHROPIC_AUTH_TOKEN : 'done'));
+  process.exit(Number(process.env.STUB_EXIT || 0));
+});`;
+function stubs(t) {
+  const bin = tmp(t, 'exec-bin-');
+  for (const n of ['codex', 'claude']) {
+    fs.writeFileSync(path.join(bin, n + '.js'), STUB_JS);
+    if (process.platform === 'win32') fs.writeFileSync(path.join(bin, n + '.cmd'), `@node "%~dp0${n}.js" %*\r\n`);
+    else { fs.writeFileSync(path.join(bin, n), `#!/bin/sh\nexec node "$(dirname "$0")/${n}.js" "$@"\n`); fs.chmodSync(path.join(bin, n), 0o755); }
+  }
+  return bin;
+}
+function runExec(t, { adapter, model, extraEnv = {}, key = KEY }) {
+  const wt = repo(t); const bin = stubs(t); const out = tmp(t, 'exec-out-'); const home = tmp(t, 'exec-home-');
+  const prompt = path.join(out, 'p.md'); fs.writeFileSync(prompt, 'DO THE CARD');
+  const result = path.join(out, 'r.json');
+  const env = { ...process.env, PATH: bin + path.delimiter + process.env.PATH, STUB_OUT: out, HOME: home, USERPROFILE: home, STUB_COMMIT: '1', ...extraEnv };
+  delete env.DEEPSEEK_API_KEY; delete env.ANTHROPIC_API_KEY; if (key) env.DEEPSEEK_API_KEY = key;
+  const r = spawnSync(process.execPath, [EXEC, `--adapter=${adapter}`, `--model=${model}`, '--worktree', wt, '--prompt-file', prompt, '--result-file', result], { env, encoding: 'utf8', windowsHide: true });
+  const read = (f) => { try { return JSON.parse(fs.readFileSync(path.join(out, f), 'utf8')); } catch { return null; } };
+  return { r, wt, out, result: fs.existsSync(result) ? JSON.parse(fs.readFileSync(result, 'utf8')) : null, resultPath: result, codex: read('codex.json'), claude: read('claude.json'), home };
+}
+
+test('codex executor: exact argv, prompt on stdin, result file with commits', (t) => {
+  const x = runExec(t, { adapter: 'codex', model: 'gpt-5.6-sol-high' });
+  assert.equal(x.r.status, 0, x.r.stdout + x.r.stderr);
+  const gitDir = require('child_process').execFileSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: x.wt, encoding: 'utf8' }).trim();
+  assert.deepEqual(x.codex.argv, ['exec', '-C', x.wt, '-m', 'gpt-5.6-sol', '-c', 'model_reasoning_effort=high', '--sandbox', 'workspace-write', '-o', x.resultPath + '.last.txt', '--add-dir', gitDir]);
+  assert.match(x.codex.stdin, /^DO THE CARD\n\n## Executor note\n/);
+  assert.equal(fs.realpathSync(x.codex.cwd), fs.realpathSync(x.wt));
+  assert.equal(x.result.ok, true); assert.equal(x.result.exitCode, 0);
+  assert.equal(x.result.lastMessage, 'codex last message');
+  assert.match(x.result.commits[0], /stub work/);
+  assert.ok(fs.existsSync(x.wt), 'worktree is never removed');
+});
+
+test('codex default (empty id): no -m, project default effort', (t) => {
+  const x = runExec(t, { adapter: 'codex', model: '' });
+  assert.equal(x.r.status, 0, x.r.stdout + x.r.stderr);
+  assert.equal(x.codex.argv.includes('-m'), false);
+  assert.ok(x.codex.argv.includes('model_reasoning_effort=medium'));
+});
+
+test('codex without commits is reported as failure (no commits)', (t) => {
+  const x = runExec(t, { adapter: 'codex', model: '', extraEnv: { STUB_COMMIT: '' } });
+  assert.equal(x.r.status, 1);
+  assert.equal(x.result.ok, false); assert.equal(x.result.error, 'no commits');
+});
+
+test('deepseek executor: env only in the child, key absent from argv, stdout, result file', (t) => {
+  const x = runExec(t, { adapter: 'deepseek', model: 'deepseek-chat', extraEnv: { ANTHROPIC_API_KEY: 'real-anthropic-key', STUB_ECHO_KEY: '1' } });
+  assert.equal(x.r.status, 0, x.r.stdout + x.r.stderr);
+  assert.deepEqual(x.claude.argv, ['-p', '--allowedTools', 'Bash', 'Edit', 'Write', 'Read', 'Glob', 'Grep']);
+  assert.deepEqual(x.claude.env, { ANTHROPIC_BASE_URL: 'https://api.deepseek.com/anthropic', ANTHROPIC_AUTH_TOKEN: KEY, ANTHROPIC_MODEL: 'deepseek-chat' });
+  assert.match(x.claude.stdin, /^DO THE CARD\n\n## Executor note\n/);
+  assert.equal(JSON.stringify(x.claude.argv).includes(KEY), false);
+  assert.equal((x.r.stdout + x.r.stderr).includes(KEY), false);
+  const raw = fs.readFileSync(x.resultPath, 'utf8');
+  assert.equal(raw.includes(KEY), false);
+  assert.match(x.result.lastMessage, /claude says \*\*\*/); // the stub echoed the key: it was redacted
+  assert.equal(JSON.stringify(x.result).includes('real-anthropic-key'), false);
+});
+
+test('deepseek key from ~/.kenaz/credentials.yaml; missing key fails before anything starts', (t) => {
+  const none = runExec(t, { adapter: 'deepseek', model: 'deepseek-chat', key: null });
+  assert.equal(none.r.status, 2); assert.match(none.r.stderr, /no API key/);
+  assert.equal(none.claude, null); assert.equal(none.result, null);
+  // credentials file route (home is a temp dir)
+  const wt = repo(t); const bin = stubs(t); const out = tmp(t, 'exec-out-'); const home = tmp(t, 'exec-home-');
+  fs.mkdirSync(path.join(home, '.kenaz')); fs.writeFileSync(path.join(home, '.kenaz', 'credentials.yaml'), `other: 1\ndeepseek_api_key: "${KEY}"\n`);
+  const prompt = path.join(out, 'p.md'); fs.writeFileSync(prompt, 'P');
+  const env = { ...process.env, PATH: bin + path.delimiter + process.env.PATH, STUB_OUT: out, HOME: home, USERPROFILE: home, STUB_COMMIT: '1' };
+  delete env.DEEPSEEK_API_KEY;
+  const r = spawnSync(process.execPath, [EXEC, '--adapter=deepseek', '--model=deepseek-reasoner', '--worktree', wt, '--prompt-file', prompt, '--result-file', path.join(out, 'r.json')], { env, encoding: 'utf8', windowsHide: true });
+  assert.equal(r.status, 0, r.stdout + r.stderr);
+  assert.equal(JSON.parse(fs.readFileSync(path.join(out, 'claude.json'), 'utf8')).env.ANTHROPIC_AUTH_TOKEN, KEY);
+});
+
+// ---- kenaz subagent set/unset/show ----
+const dmRun = (argv, cwd) => { const out = []; const code = dm.main(argv, (l) => out.push(l), cwd); return { code, out: out.join('\n') }; };
+const modelsOf = (p) => JSON.parse(fs.readFileSync(path.join(p, '.kenaz', 'dashboard-models.json'), 'utf8'));
+
+test('subagent set/unset/show: codex:, deepseek:, codex: alone', (t) => {
+  const p = tmp(t, 'dm-');
+  assert.equal(dmRun(['set', 'codex:gpt-5.6-sol'], p).code, 0);
+  assert.equal(dmRun(['set', 'deepseek:deepseek-chat', '--rigor', 'low'], p).code, 0);
+  assert.equal(dmRun(['set', 'codex:', '--rigor', 'high'], p).code, 0);
+  assert.deepEqual(modelsOf(p), { dispatchModel: 'codex:gpt-5.6-sol', dispatchModelByRigor: { low: 'deepseek:deepseek-chat', high: 'codex:' } });
+  const shown = dmRun([], p).out;
+  assert.match(shown, /low\s+deepseek:deepseek-chat -> executor deepseek/);
+  assert.match(shown, /medium\s+codex:gpt-5.6-sol -> executor codex/);
+  assert.match(shown, /high\s+codex: -> executor codex/);
+  dmRun(['unset', '--rigor', 'low'], p); dmRun(['unset'], p);
+  assert.deepEqual(modelsOf(p), { dispatchModelByRigor: { high: 'codex:' } });
+});
+
+test('subagent set: unknown codex id and unknown prefix are refused with the valid list; nothing written', (t) => {
+  const p = tmp(t, 'dm-');
+  const a = dmRun(['set', 'codex:nope'], p);
+  assert.equal(a.code, 1); assert.match(a.out, /unknown codex model 'nope'.*codex:gpt-5\.6-sol/);
+  const b = dmRun(['set', 'deepseek:gpt'], p);
+  assert.equal(b.code, 1); assert.match(b.out, /deepseek:deepseek-chat, deepseek:deepseek-reasoner/);
+  const c = dmRun(['set', 'gemini:pro'], p);
+  assert.equal(c.code, 1); assert.match(c.out, /unknown executor prefix 'gemini:'.*codex:<id>, deepseek:<model>/);
+  assert.equal(fs.existsSync(path.join(p, '.kenaz', 'dashboard-models.json')), false);
+  assert.equal(dmRun(['set', 'opus'], p).code, 0, 'plain Claude ids keep working');
+});
+
+// ---- dispatch.js: executor block vs the unchanged Claude control ----
+test('dispatch: executor block for codex:/deepseek:, byte-for-byte agentParams for a Claude id', (t) => {
+  const sb = tmp(t, 'exec-dispatch-');
+  for (const d of ['backlog', 'active', 'done', 'blocked', 'cancel']) fs.mkdirSync(path.join(sb, '.kenaz', 'tasks', d), { recursive: true });
+  fs.mkdirSync(path.join(sb, '.kenaz', 'locks'), { recursive: true });
+  fs.writeFileSync(path.join(sb, 'README.md'), 'x'); fs.writeFileSync(path.join(sb, '.gitignore'), '.formation/worktrees/\n.kenaz/\n');
+  git(sb, ['init', '-q']); git(sb, ['add', '-A']); git(sb, ['commit', '-q', '--no-verify', '-m', 'init']);
+  const env = { ...process.env, DEEPSEEK_API_KEY: KEY }; delete env.CLAUDE_PROJECT_DIR; delete env.CODEX_SESSION_ID; delete env.CODEX_THREAD_ID;
+  const sh = (script, args) => spawnSync(process.execPath, [script, ...args], { env, encoding: 'utf8', windowsHide: true, cwd: ROOT });
+  const mk = sh(TASKAPI, ['--project-path', sb, 'create', '--title', 't2422', '--description', 'd', '--scope-paths', 'zzz/a.js', '--requirements', 'r1',
+    '--acceptance-criteria', 'a1', '--acceptance-criteria', 'a2', '--acceptance-criteria', 'a3', '--technical-notes', 't1', '--technical-notes', 't2', '--force']);
+  const id = ((mk.stdout || '').match(/TASK_\d+/) || [])[0]; assert.ok(id, mk.stdout + mk.stderr);
+  const disp = (model) => {
+    fs.writeFileSync(path.join(sb, '.kenaz', 'dashboard-models.json'), JSON.stringify({ dispatchModel: model }));
+    const r = sh(DISPATCH, ['--skill=do', `--task=${id}`, '--dispatch-mode=subagent', '--project-path', sb, '--force']);
+    return { r, j: (() => { try { return JSON.parse(r.stdout); } catch { return null; } })() };
+  };
+  const cx = disp('codex:gpt-5.6-sol');
+  assert.ok(cx.j, cx.r.stdout + cx.r.stderr);
+  assert.equal(cx.j.agentParams, undefined);
+  assert.equal(cx.j.executor.adapter, 'codex'); assert.equal(cx.j.executor.branchName, `task/${id.toLowerCase()}`);
+  assert.ok(fs.existsSync(cx.j.executor.worktreePath), 'worktree created');
+  assert.equal(fs.readFileSync(cx.j.executor.promptFile, 'utf8'), cx.j.promptText);
+  assert.match(cx.j.executor.command, /exec\.js" --adapter=codex --model="gpt-5\.6-sol" --worktree/);
+  const ds = disp('deepseek:deepseek-chat');
+  assert.equal(ds.j.executor.adapter, 'deepseek');
+  assert.equal(ds.r.stdout.includes(KEY) || ds.r.stderr.includes(KEY), false, 'key never in the dispatch JSON or logs');
+  assert.equal(fs.readFileSync(ds.j.executor.promptFile, 'utf8').includes(KEY), false);
+  // control: Claude id -> the existing agentParams output, no executor block
+  const cl = disp('claude-sonnet-5-5');
+  assert.equal(cl.j.executor, undefined);
+  assert.equal(cl.j.agentParams.model, 'sonnet'); // cross-project sandbox: Agent isolation omitted, as before
+  assert.deepEqual(Object.keys(cl.j.agentParams), ['description', 'model']);
+  // a missing DeepSeek key is refused before any worktree/side effect
+  const noKey = { ...env }; delete noKey.DEEPSEEK_API_KEY; noKey.USERPROFILE = noKey.HOME = tmp(t, 'nokey-');
+  fs.writeFileSync(path.join(sb, '.kenaz', 'dashboard-models.json'), JSON.stringify({ dispatchModel: 'deepseek:deepseek-chat' }));
+  const nk = spawnSync(process.execPath, [DISPATCH, '--skill=do', `--task=${id}`, '--dispatch-mode=subagent', '--project-path', sb, '--force'], { env: noKey, encoding: 'utf8', windowsHide: true, cwd: ROOT });
+  assert.notEqual(nk.status, 0); assert.match(nk.stderr, /no API key/);
+});
+
+test('codex that edits but cannot commit (sandbox): exec.js commits the leftovers, telemetry excluded', (t) => {
+  const id = { GIT_AUTHOR_NAME: 't', GIT_AUTHOR_EMAIL: 't@t', GIT_COMMITTER_NAME: 't', GIT_COMMITTER_EMAIL: 't@t' };
+  const x = runExec(t, { adapter: 'codex', model: '', extraEnv: { STUB_COMMIT: '', STUB_WRITE_ONLY: '1', ...id } });
+  assert.equal(x.r.status, 0, x.r.stdout + x.r.stderr);
+  assert.equal(x.result.ok, true); assert.ok(x.result.executorCommit);
+  assert.match(x.result.commits[0], /codex executor: agent's changes/);
+  const files = require('child_process').execFileSync('git', ['show', '--name-only', '--format=', 'HEAD'], { cwd: x.wt, encoding: 'utf8' }).trim();
+  assert.strictEqual(files, 'left.txt');
+});

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/.specialist/Ansuz/RULES.md

@@ -68,8 +68,11 @@ the real defect BEFORE carding or dispatching.
   (plus `--project-path <pin>`). Pass top-level promptText as the Agent prompt and agentParams
   verbatim; agentParams.model is already the Agent enum - never substitute a model (never inherit
   opus). dispatch.js moves the card to active.
-- The dispatch model is the project's setting: `kenaz model` shows it per rigor, `kenaz model set <id> [--rigor r]`
+- The dispatch model is the project's setting: `kenaz subagent` (or /kenaz subagent) shows it per rigor, `kenaz subagent set <id> [--rigor r]`
   changes it (writes .kenaz/dashboard-models.json). Your own model is the user's session model (/model).
+- Executor model (`kenaz subagent set codex:<id>` or `deepseek:<model>`): dispatch.js prints an `executor` block instead of
+  agentParams. Run `executor.command` with Bash run_in_background, wait for the completion notice, read `executor.resultFile`
+  (ok, exitCode, lastMessage, commits; `no commits` = failure), then verify and merge `executor.branchName` as usual.
 - Worktree subagents must commit; cleanup deletes uncommitted edits. Remove Kenaz worktrees only
   via .formation/tools/worktree-reclaim.js (it unlinks node_modules junctions first).
 
@@ -80,7 +83,7 @@ the real defect BEFORE carding or dispatching.
   through dev/scripts/rust-verify-worktree.js.
 
 ## Handoff
-Frozen since 2026-10-10 (ANSUZ_SLIM_PLAN): no handoff snapshots. The task cards and git history are the record.
+One ISBAR markdown file per handoff in <project>/.kenaz/handoffs/, created by .specialist/tools/handoff-doc.js new --topic ... (Identification filled in; you fill Situation, Background, Assessment, Recommendation). Write one when the user asks for a handoff or a pause, when context is nearly full, or when a session ends with unfinished work. Boot lists the newest and Ansuz reads it in full before proposing the agenda. The old JSON snapshots (ansuz_handoff_snapshot, handoffs/*.json) stay frozen.
 
 ## Wishing Well
 When the Kenaz app itself blocks or degrades the work, file kenaz_wish_create (bug|feature|question,
@@ -91,6 +94,8 @@ Write a lesson automatically (no asking, one line in the report naming it) when
 - Layer: user-wide preference -> `--scope user` (~/.kenaz/knowledge, local, never synced); project fact -> `--scope project` (<project>/.kenaz/knowledge).
 - Type decides where it acts (a stored note alone changes nothing): `pitfall` needs `--trigger '<tool regex> | <input regex>'`, memory-guard fires it right before the matching tool call (add `--cause` = the command that caused it; the write is refused if the trigger misses it or fires on >20% of recent tool calls; `--symptom` records how the mistake shows up); `fact` (`--paths` limits it to cards touching those paths) and `check` go into the dispatch prompt (max 5 lines / 600 bytes); `pref` shows in the boot banner.
 - Lessons idle for 30 days move to `<layer>/archive/` (pref exempt); `kenaz learn list` shows fire counts.
+- Lifecycle (lessons must not just pile up): when the boot banner shows `[lessons] N to graduate`, run `kenaz learn review` and propose turning the top candidate into code (a test, a hook check, or a rule in the project's CLAUDE.md/AGENTS.md; never edit ~/.kenaz/core), then `kenaz learn graduate <id> --to <commit or file>`. That is the preferred outcome. A correction that matches an existing lesson is a recurrence, not a new lesson: `add` bumps `recurrences` instead of writing (max 20 active per layer; `kenaz learn merge <id1> <id2> --text "<general rule>"` to make room). A lesson about Kenaz itself gets `--about kenaz`; `review` lists it with the hint to report it via `kenaz_wish_create scope=kenaz` (nothing is sent automatically).
+- History harvest (TASK_2427): when the boot banner shows `[learn] N history items to review` (or `[lessons] ... N history items`), run `kenaz learn review`. Each item (rework, failed executor run, blocked card, handoff risk line) has a ready `kenaz learn add ... --source harvest:<id>`: fill in the why, run it for items that reveal a reusable lesson, ignore the rest. The metric suggestions (first-pass rate per rigor, rework-heavy files) are suggestions: show them to the user, never apply `kenaz subagent set` yourself. Lessons from a correction nudge use `--source correction-nudge`. Benefit is measured in `kenaz stats` (Self-improvement); the keep/remove rule is in dev/research/self-improvement/DESIGN.md.
 
 ## REA (reverse-engineering reference products)
 REA (github.com/morluto/rea, MCP server `rea`) is optional and user-installed; the boot banner's `[rea]` line says whether it is on.