kenaz 0.3.15 → 0.3.16

package/core/.formation/bifrost/exec.js

@@ -4,9 +4,11 @@
  * Bifrost executors for `kenaz subagent` (TASK_2422): run a dispatched card with a non-Claude model.
  *   codex:<id>      `codex exec` in the card's worktree (id = an entry of openai/models.json; `codex:` = default)
  *   deepseek:<m>    `claude -p` in the worktree against DeepSeek's Anthropic-compatible endpoint
+ *   claude          (TASK_2430) `claude -p --model <alias>` on the user's own Claude login: used by dispatch.js inside a
+ *                   `kenaz launch` session, where the Agent tool can only reach the other vendor
  *
  * CLI (dispatch.js prints the exact command):
- *   node exec.js --adapter=codex|deepseek --model=<id> --worktree <dir> --prompt-file <f> --result-file <f>
+ *   node exec.js --adapter=codex|deepseek|claude --model=<id> --worktree <dir> --prompt-file <f> --result-file <f>
  * The prompt goes to the child on stdin (never argv). The DeepSeek key is only in the child's env and
  * is redacted from everything written. The worktree is never removed. Exit 0 = child ok AND new commits.
  */
@@ -63,6 +65,7 @@ function buildChild({ adapter, id, worktree, lastFile, key, gitDir }) {
     if (gitDir) args.push('--add-dir', gitDir);
     return { bin: 'codex', args, env: {}, unset: [] };
   }
+  if (adapter === 'claude') return { bin: 'claude', args: ['-p', '--model', id, '--allowedTools', ...CLAUDE_TOOLS], env: {}, unset: CLAUDE_UNSET };
   return { bin: 'claude', args: ['-p', '--allowedTools', ...CLAUDE_TOOLS], env: deepseekEnv(id, key), unset: DEEPSEEK_UNSET };
 }
 
@@ -90,6 +93,10 @@ async function deepseekModels(key, fetchFn = globalThis.fetch, timeoutMs = 3000)
   } catch { return null; }
 }
 const DEEPSEEK_UNSET = ['ANTHROPIC_API_KEY']; // never send a real Anthropic key to another vendor
+// The claude adapter must reach Claude, not the vendor `kenaz launch` pointed this session at: drop every override
+// launch sets (the vendor key lives in ANTHROPIC_AUTH_TOKEN; DEEPSEEK_API_KEY is dropped too, the child does not need it).
+const CLAUDE_UNSET = ['ANTHROPIC_BASE_URL', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_MODEL', 'ANTHROPIC_SMALL_FAST_MODEL', 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL', 'ANTHROPIC_DEFAULT_OPUS_MODEL', 'CLAUDE_CODE_SUBAGENT_MODEL', 'CLAUDE_CODE_MAX_CONTEXT_TOKENS', 'KENAZ_PROVIDER', 'DEEPSEEK_API_KEY'];
 
 const git = (cwd, args) => spawnSync('git', args, { cwd, encoding: 'utf8', windowsHide: true });
 // Same exclusions as the dispatch prompt's commit command (session telemetry never rides along).
@@ -108,11 +115,13 @@ const winQuote = (a) => (/^[\w@%+=:,./\\-]+$/.test(a) ? a : '"' + a.replace(/"/g
 
 /** Run the executor; resolves to the result object (also written to resultFile). Never throws for child failures. */
 async function run({ adapter, model = '', worktree, promptFile, resultFile, env = process.env, home = os.homedir() }) {
-  if (!['codex', 'deepseek'].includes(adapter)) throw new Error(`unknown adapter '${adapter}'`);
+  if (!['codex', 'deepseek', 'claude'].includes(adapter)) throw new Error(`unknown adapter '${adapter}'`);
   const started = Date.now();
   const key = adapter === 'deepseek' ? deepseekKey(env, home) : null;
   if (adapter === 'deepseek' && !key) throw new Error('deepseek: no API key (set DEEPSEEK_API_KEY or deepseek_api_key in ~/.kenaz/credentials.yaml)');
-  const redact = (s) => (key ? String(s).split(key).join('***') : String(s));
+  // claude adapter: the vendor key is not given to the child, but redact it (and the launch token) from anything written anyway.
+  const secrets = adapter === 'claude' ? [deepseekKey(env, home), env.ANTHROPIC_AUTH_TOKEN].filter(Boolean) : key ? [key] : [];
+  const redact = (s) => secrets.reduce((acc, k) => acc.split(k).join('***'), String(s));
   const base = (git(worktree, ['rev-parse', 'HEAD']).stdout || '').trim();
   const lastFile = resultFile + '.last.txt';
   const gitDir = (git(worktree, ['rev-parse', '--path-format=absolute', '--git-common-dir']).stdout || '').trim();
@@ -148,7 +157,7 @@ async function main(argv) {
     if (m) a[m[1]] = m[2] !== undefined ? m[2] : argv[++i];
   }
   if (!a.adapter || !a.worktree || !a['prompt-file'] || !a['result-file']) {
-    console.error('usage: exec.js --adapter=codex|deepseek --model=<id> --worktree <dir> --prompt-file <f> --result-file <f>');
+    console.error('usage: exec.js --adapter=codex|deepseek|claude --model=<id> --worktree <dir> --prompt-file <f> --result-file <f>');
     return 2;
   }
   try {

package/core/.formation/bifrost/provider-launch.js

@@ -42,7 +42,8 @@ function plan(argv, env = process.env, home = os.homedir(), live = null) {
   if (!valid.includes(id)) throw new Error(`unknown ${provider} model '${id}'; valid: ${valid.join(', ')}`);
   const key = p.key(env, home);
   if (!key) throw new Error(`${provider}: no API key (${p.keyHelp})`);
-  const childEnv = { ...env, ...p.env(id, key, live && live[id]), CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' };
+  const childEnv = { ...env, ...p.env(id, key, live && live[id]), CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+    KENAZ_PROVIDER: provider }; // tools (dispatch.js) tell the session runs on another vendor
   for (const k of p.unset) delete childEnv[k];
   return { bin: 'claude', args: rest, env: childEnv, provider, model: id, context: childEnv.CLAUDE_CODE_MAX_CONTEXT_TOKENS };
 }

package/core/.formation/bifrost/provider-launch.test.js

@@ -31,6 +31,7 @@ test('deepseek: every model slot points at DeepSeek, key only in the child env,
   assert.strictEqual(e.CLAUDE_CODE_MAX_CONTEXT_TOKENS, '1048576', 'V4 window from the built-in table when the live list is unavailable');
   assert.strictEqual(e.ANTHROPIC_API_KEY, undefined);
   assert.strictEqual(e.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC, '1');
+  assert.strictEqual(e.KENAZ_PROVIDER, 'deepseek', 'tools can tell the session runs on another vendor');
   assert.strictEqual(e.PATH, 'p', 'the rest of the env is kept');
   assert.ok(!JSON.stringify(c.args).includes(KEY) && !lines.join('\n').includes(KEY), 'key never in argv or output');
 });

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

@@ -31,7 +31,7 @@ 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 } }));
+    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 }, fullEnv: process.env }));
   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');
@@ -148,6 +148,62 @@ test('subagent set: unknown codex id and unknown prefix are refused with the val
 });
 
 // ---- dispatch.js: executor block vs the unchanged Claude control ----
+const REMOVED = ['ANTHROPIC_BASE_URL', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_MODEL', 'ANTHROPIC_SMALL_FAST_MODEL', 'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL', 'ANTHROPIC_DEFAULT_OPUS_MODEL', 'CLAUDE_CODE_SUBAGENT_MODEL', 'CLAUDE_CODE_MAX_CONTEXT_TOKENS', 'KENAZ_PROVIDER'];
+test('claude executor (TASK_2430): --model alias, every launch override removed, vendor key nowhere', (t) => {
+  const launchEnv = Object.fromEntries(REMOVED.map((k) => [k, 'x-' + k])); launchEnv.ANTHROPIC_AUTH_TOKEN = KEY; launchEnv.STUB_ECHO_KEY = '1';
+  const x = runExec(t, { adapter: 'claude', model: 'opus', extraEnv: launchEnv });
+  assert.equal(x.r.status, 0, x.r.stdout + x.r.stderr);
+  assert.deepEqual(x.claude.argv, ['-p', '--model', 'opus', '--allowedTools', 'Bash', 'Edit', 'Write', 'Read', 'Glob', 'Grep']);
+  for (const k of [...REMOVED, 'DEEPSEEK_API_KEY']) assert.equal(x.claude.fullEnv[k], undefined, k + ' reached the claude child');
+  assert.match(x.claude.stdin, /^DO THE CARD\n\n## Executor note\n/);
+  assert.equal(JSON.stringify(x.claude.fullEnv).includes(KEY), false);
+  assert.equal(JSON.stringify(x.claude.argv).includes(KEY), false);
+  assert.equal((x.r.stdout + x.r.stderr).includes(KEY), false);
+  assert.equal(fs.readFileSync(x.resultPath, 'utf8').includes(KEY), false);
+  assert.equal(x.result.ok, true); assert.match(x.result.commits[0], /stub work/);
+});
+
+test('claude executor: edits left uncommitted are committed by exec.js; no commits = failure', (t) => {
+  const left = runExec(t, { adapter: 'claude', model: 'sonnet', extraEnv: { STUB_COMMIT: '', STUB_WRITE_ONLY: '1', GIT_AUTHOR_NAME: 't', GIT_AUTHOR_EMAIL: 't@t', GIT_COMMITTER_NAME: 't', GIT_COMMITTER_EMAIL: 't@t' } });
+  assert.equal(left.r.status, 0, left.r.stdout + left.r.stderr);
+  assert.ok(left.result.executorCommit);
+  const none = runExec(t, { adapter: 'claude', model: 'sonnet', extraEnv: { STUB_COMMIT: '' } });
+  assert.equal(none.r.status, 1); assert.equal(none.result.error, 'no commits');
+});
+
+test('dispatch under KENAZ_PROVIDER: Claude id -> executor adapter claude, no agentParams; without it agentParams as before', (t) => {
+  const sb = tmp(t, 'exec-dispatch-claude-');
+  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 base = { ...process.env }; delete base.CLAUDE_PROJECT_DIR; delete base.CODEX_SESSION_ID; delete base.CODEX_THREAD_ID; delete base.KENAZ_PROVIDER;
+  const sh = (script, args, env) => spawnSync(process.execPath, [script, ...args], { env, encoding: 'utf8', windowsHide: true, cwd: ROOT });
+  const mk = sh(TASKAPI, ['--project-path', sb, 'create', '--title', 't2430', '--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'], base);
+  const id = ((mk.stdout || '').match(/TASK_\d+/) || [])[0]; assert.ok(id, mk.stdout + mk.stderr);
+  const disp = (model, provider) => {
+    fs.writeFileSync(path.join(sb, '.kenaz', 'dashboard-models.json'), JSON.stringify({ dispatchModel: model }));
+    const env = { ...base, ...(provider ? { KENAZ_PROVIDER: provider } : {}), DEEPSEEK_API_KEY: KEY };
+    const r = sh(DISPATCH, ['--skill=do', `--task=${id}`, '--dispatch-mode=subagent', '--project-path', sb, '--force'], env);
+    return { r, j: (() => { try { return JSON.parse(r.stdout); } catch { return null; } })() };
+  };
+  const ds = disp('claude-opus-5', 'deepseek');
+  assert.ok(ds.j, ds.r.stdout + ds.r.stderr);
+  assert.equal(ds.j.agentParams, undefined);
+  assert.equal(ds.j.executor.adapter, 'claude'); assert.equal(ds.j.executor.model, 'opus');
+  assert.equal(ds.j.executor.branchName, `task/${id.toLowerCase()}`);
+  assert.ok(fs.existsSync(ds.j.executor.worktreePath)); assert.ok(ds.j.executor.promptFile && ds.j.executor.resultFile && ds.j.executor.note);
+  assert.match(ds.j.executor.command, /exec\.js" --adapter=claude --model="opus" --worktree/);
+  assert.equal(ds.r.stdout.includes(KEY) || ds.r.stderr.includes(KEY), false);
+  const an = disp('claude-sonnet-5-5', 'anthropic'); // control: provider anthropic = no executor
+  assert.equal(an.j.executor, undefined); assert.equal(an.j.agentParams.model, 'sonnet');
+  const none = disp('claude-sonnet-5-5', null); // control: no KENAZ_PROVIDER = byte-for-byte as before
+  assert.equal(none.j.executor, undefined);
+  assert.deepEqual(Object.keys(none.j.agentParams), ['description', 'model']); assert.equal(none.j.agentParams.model, 'sonnet');
+});
+
 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 });

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

@@ -1063,6 +1063,12 @@ async function getSubagentDispatchParams(options) {
       return null;
     }
   }
+  // TASK_2430: in a `kenaz launch` session the Agent tool only reaches the other vendor, so a Claude model
+  // id runs as a `claude -p` executor on the user's own Claude login instead.
+  if (!isCodex && !exec && process.env.KENAZ_PROVIDER && process.env.KENAZ_PROVIDER !== 'anthropic') {
+    const fam = translateModelForAgentTool(rawModel).model;
+    if (fam) exec = { adapter: 'claude', id: fam };
+  }
   // TASK_2315: Codex inherits the session model — nothing to translate or pass.
   const translated = isCodex || exec ? { model: null, lossless: true } : translateModelForAgentTool(rawModel);
   if (!isCodex && !exec && !translated.model) {

package/core/.specialist/Ansuz/RULES.md

@@ -73,6 +73,7 @@ the real defect BEFORE carding or dispatching.
 - 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.
+  In a `kenaz launch` session (KENAZ_PROVIDER set), Claude subagents also come as an executor block (adapter `claude`, they use the user's Claude quota).
 - Worktree subagents must commit; cleanup deletes uncommitted edits. Remove Kenaz worktrees only
   via .formation/tools/worktree-reclaim.js (it unlinks node_modules junctions first).
 

package/core/KENAZ_CORE_VERSION

@@ -1 +1 @@
-0.3.15
+0.3.16

package/lib/cli.js

@@ -35,7 +35,8 @@ function installer() {
 
 /** A core module from the installed core, else this checkout; null when neither is there. */
 function coreModule(p, ...rel) {
-  for (const f of [path.join(p.core, ...rel), path.join(__dirname, '..', '..', '..', ...rel)]) {
+  // installed core, then the core bundled in this npm package (npx before `kenaz install`), then the repo checkout
+  for (const f of [path.join(p.core, ...rel), path.join(PKG_ROOT, 'core', ...rel), path.join(__dirname, '..', '..', '..', ...rel)]) {
     if (fs.existsSync(f)) return require(f);
   }
   return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kenaz",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "description": "Install Kenaz (plugin, hooks, kenaz-server) for Claude Code and Codex: npx kenaz install",
   "bin": {
     "kenaz": "bin/kenaz.js"
@@ -20,11 +20,11 @@
     "test": "node --test lib/cli.test.js"
   },
   "optionalDependencies": {
-    "@kenazai/server-darwin-arm64": "0.3.15",
-    "@kenazai/server-darwin-x64": "0.3.15",
-    "@kenazai/server-linux-arm64": "0.3.15",
-    "@kenazai/server-linux-x64": "0.3.15",
-    "@kenazai/server-win32-x64": "0.3.15"
+    "@kenazai/server-darwin-arm64": "0.3.16",
+    "@kenazai/server-darwin-x64": "0.3.16",
+    "@kenazai/server-linux-arm64": "0.3.16",
+    "@kenazai/server-linux-x64": "0.3.16",
+    "@kenazai/server-win32-x64": "0.3.16"
   },
   "license": "UNLICENSED",
   "repository": {