kenaz 0.0.0-stage → 0.3.2

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

@@ -0,0 +1,234 @@
+// TASK_1813: sub-agent dispatch Bifrost routing guard + dispatchMode contract tests.
+// Mirrors the kenaz.rs tool_dispatch invariant (sigil_2a3f3b75) on the JS side:
+// a non-claude dispatchFamily must fail loudly on the sub-agent path — never a
+// silent Claude fallback (the Agent tool only accepts Claude models).
+// TASK_1815: agentParams.model contract — the Agent tool only accepts the
+// family enum sonnet|opus|haiku|fable (measured 2026-07-26: full ids like
+// 'claude-fable-5' raise InputValidationError). Emitted model must be a
+// translated enum member, unmappable ids must fail loudly, and the version
+// granularity loss must be visible (modelTranslation + stderr).
+// Usage: node .formation/tools/__tests__/subagent-bifrost-guard.test.js
+// Exit 0=all pass, non-zero=at least one failure
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// resolve repo root (works from worktree and main repo) — same as m1-claim-gate.test.js
+function resolveRoot() {
+  var d = path.resolve(__dirname);
+  for (var i = 0; i < 10; i++) {
+    if (fs.existsSync(path.join(d, '.kenaz')) && fs.existsSync(path.join(d, '.formation'))) return d;
+    var parent = path.dirname(d); if (parent === d) break; d = parent;
+  }
+  if (process.env.CLAUDE_PROJECT_DIR) return process.env.CLAUDE_PROJECT_DIR;
+  throw new Error('Cannot resolve repo root from ' + __dirname);
+}
+const WT = resolveRoot();
+const SB = path.join(os.tmpdir(), 't1813_guard_' + process.pid);
+const TASKAPI = path.join(WT, '.collaboration/core/task-api.js');
+const DISPATCH = path.join(WT, '.formation/tools/dispatch.js');
+const MODELS = path.join(SB, '.kenaz', 'dashboard-models.json');
+const env = { ...process.env };
+delete env.CLAUDE_PROJECT_DIR;
+
+for (const d of [
+  '.kenaz/tasks/backlog', '.kenaz/tasks/active', '.kenaz/tasks/done',
+  '.kenaz/tasks/blocked', '.kenaz/tasks/cancel', '.kenaz/locks',
+]) {
+  fs.mkdirSync(path.join(SB, d), { recursive: true });
+}
+
+const run = (script, args, opts) =>
+  spawnSync(process.execPath, [script, ...args], Object.assign({ encoding: 'utf8', env, windowsHide: true, cwd: WT }, opts || {}));
+
+let pass = 0, fail = 0;
+const check = (name, cond, detail) => {
+  console.log((cond ? 'PASS' : 'FAIL') + ' | ' + name + (cond ? '' : ' | ' + detail));
+  cond ? pass++ : fail++;
+};
+
+// Create one real backlog task via task-api so the guard is exercised on the
+// TASK_ path (loadTask + scope gate), not only free-text.
+const mk = run(TASKAPI, ['--project-path', SB, 'create', '--title', 't1813 guard target',
+  '--description', 'guard test task', '--scope-paths', 'zzz/guard.js',
+  '--requirements', 'r1', '--acceptance-criteria', 'a1', '--acceptance-criteria', 'a2', '--acceptance-criteria', 'a3',
+  '--technical-notes', 't1', '--technical-notes', 't2', '--force']);
+const TASK_ID = ((mk.stdout || '').match(/TASK_\d+/) || [])[0];
+check('setup: sandbox backlog task created', !!TASK_ID, ((mk.stdout || '') + (mk.stderr || '')).slice(0, 300));
+
+const dispatchSub = () =>
+  run(DISPATCH, ['--skill=do', '--task=' + TASK_ID, '--dispatch-mode=subagent', '--project-path', SB]);
+const setModels = (obj) => fs.writeFileSync(MODELS, JSON.stringify(obj, null, 2));
+
+// TASK_1815: the Agent tool model enum — keep in sync with AGENT_TOOL_MODEL_ENUM
+// in dispatch.js (harness constraint, measured 2026-07-26).
+const AGENT_TOOL_MODEL_ENUM = ['sonnet', 'opus', 'haiku', 'fable'];
+
+// ── [1] allow: dispatchFamily=claude → exit 0, usable JSON payload ──────────
+setModels({ dispatchModel: 'claude-fable-5[1m]', dispatchFamily: 'claude', dispatchAdapter: null });
+{
+  const r = dispatchSub();
+  let j = null;
+  try { j = JSON.parse(r.stdout); } catch { /* asserted below */ }
+  check('allow claude: exit 0', r.status === 0, 'status=' + r.status + ' | ' + (r.stderr || '').slice(-300));
+  check('allow claude: stdout is JSON with agentParams', !!(j && j.promptText && j.agentParams), (r.stdout || '').slice(0, 200));
+  // TASK_1815: was `=== 'claude-fable-5'` — that value is REJECTED by the
+  // Agent tool (InputValidationError); the contract is now the family enum.
+  check('allow claude: model translated to Agent tool enum (fable)', !!j && j.agentParams.model === 'fable', j && JSON.stringify(j.agentParams));
+  check('allow claude: model is an Agent tool enum member', !!j && AGENT_TOOL_MODEL_ENUM.includes(j.agentParams.model), j && j.agentParams.model);
+  check('allow claude: modelTranslation surfaces requested id + granularity loss',
+    !!j && !!j.modelTranslation && j.modelTranslation.requested === 'claude-fable-5[1m]' &&
+    j.modelTranslation.agentToolModel === 'fable' && j.modelTranslation.granularityLoss === true,
+    j && JSON.stringify(j.modelTranslation));
+  check('allow claude: granularity loss visible on stderr',
+    (r.stderr || '').includes("model 'claude-fable-5[1m]'") && (r.stderr || '').includes('NOT expressible'), (r.stderr || '').slice(-400));
+  check('allow claude: dispatchMode falls back to subagent when field missing', !!j && j.dispatchMode === 'subagent', j && j.dispatchMode);
+}
+
+// ── [2] reject: dispatchFamily=bifrost with adapter → loud refusal ──────────
+setModels({ dispatchModel: 'gpt-5-codex', dispatchFamily: 'bifrost', dispatchAdapter: 'openai' });
+{
+  const r = dispatchSub();
+  check('reject bifrost+adapter: non-zero exit', r.status !== 0, 'status=' + r.status);
+  check('reject bifrost+adapter: no agentParams on stdout', !(r.stdout || '').includes('agentParams'), (r.stdout || '').slice(0, 200));
+  check('reject bifrost+adapter: invariant wording (refusing to silently dispatch)',
+    (r.stderr || '').includes('refusing to silently dispatch with the native Claude CLI'), (r.stderr || '').slice(-400));
+  check('reject bifrost+adapter: remediation points to Formation dispatch (kenaz_dispatch)',
+    (r.stderr || '').includes('kenaz_dispatch'), (r.stderr || '').slice(-400));
+}
+
+// ── [3] reject: dispatchFamily=bifrost, adapter missing/empty ───────────────
+setModels({ dispatchModel: 'gpt-5-codex', dispatchFamily: 'bifrost', dispatchAdapter: '  ' });
+{
+  const r = dispatchSub();
+  check('reject bifrost+empty-adapter: non-zero exit', r.status !== 0, 'status=' + r.status);
+  check('reject bifrost+empty-adapter: kenaz.rs-aligned wording',
+    (r.stderr || '').includes('dispatchAdapter is missing/empty') &&
+    (r.stderr || '').includes('refusing to silently dispatch with the native Claude CLI'), (r.stderr || '').slice(-400));
+}
+
+// ── [4] reject: unknown dispatchFamily ──────────────────────────────────────
+setModels({ dispatchModel: 'gemini-3-pro', dispatchFamily: 'gemini', dispatchAdapter: null });
+{
+  const r = dispatchSub();
+  check('reject unknown family: non-zero exit', r.status !== 0, 'status=' + r.status);
+  check('reject unknown family: kenaz.rs-aligned wording',
+    (r.stderr || '').includes("unsupported dispatchFamily 'gemini'") &&
+    (r.stderr || '').includes("(expected 'claude' or 'bifrost')"), (r.stderr || '').slice(-400));
+}
+
+// ── [5] dispatchMode contract: invalid value is loud, not silent ────────────
+setModels({ dispatchModel: 'claude-fable-5', dispatchFamily: 'claude', dispatchMode: 'yolo' });
+{
+  const r = dispatchSub();
+  let j = null; try { j = JSON.parse(r.stdout); } catch { /* asserted below */ }
+  check('dispatchMode invalid: still dispatches (exit 0)', r.status === 0, 'status=' + r.status + ' | ' + (r.stderr || '').slice(-300));
+  check('dispatchMode invalid: falls back to subagent', !!j && j.dispatchMode === 'subagent', j && j.dispatchMode);
+  check('dispatchMode invalid: loud stderr warning', (r.stderr || '').includes("dispatchMode 'yolo' is invalid"), (r.stderr || '').slice(-300));
+}
+
+// ── [6] dispatchMode contract: valid values pass through ────────────────────
+setModels({ dispatchModel: 'claude-fable-5', dispatchFamily: 'claude', dispatchMode: 'auto' });
+{
+  const r = dispatchSub();
+  let j = null; try { j = JSON.parse(r.stdout); } catch { /* asserted below */ }
+  check('dispatchMode auto: accepted', r.status === 0 && !!j && j.dispatchMode === 'auto', 'status=' + r.status + ' mode=' + (j && j.dispatchMode));
+  check('dispatchMode auto: no warning emitted', !(r.stderr || '').includes('is invalid'), (r.stderr || '').slice(-200));
+}
+
+// ── [7] TASK_1815 model mapping: every emitted model is an enum member ──────
+// Covers the NATIVE ids from dashboard/src/lib/models.ts plus the missing-field
+// fallback ('claude-sonnet-4-6', mirrors DEFAULT_DISPATCH_MODEL) and a haiku id
+// (enum member with no dashboard source entry today — must still map).
+const MAP_CASES = [
+  { raw: 'claude-fable-5-1[1m]', want: 'fable', loss: true }, // 2026-09-03: Fable 5.1 added to manifest
+  { raw: 'claude-opus-5[1m]', want: 'opus', loss: true },
+  { raw: 'claude-opus-4-8[1m]', want: 'opus', loss: true },
+  { raw: 'claude-sonnet-5', want: 'sonnet', loss: true },
+  { raw: 'claude-sonnet-4-6', want: 'sonnet', loss: true },
+  { raw: 'claude-haiku-4-5', want: 'haiku', loss: true },
+  { raw: undefined, want: 'sonnet', loss: true }, // missing field → 'claude-sonnet-4-6' fallback
+  { raw: 'fable', want: 'fable', loss: false },   // already a bare enum value → lossless, no stderr note
+];
+for (const c of MAP_CASES) {
+  const label = c.raw === undefined ? '<missing>' : c.raw;
+  setModels({ ...(c.raw === undefined ? {} : { dispatchModel: c.raw }), dispatchFamily: 'claude' });
+  const r = dispatchSub();
+  let j = null; try { j = JSON.parse(r.stdout); } catch { /* asserted below */ }
+  check(`map ${label}: → '${c.want}' (enum member)`,
+    r.status === 0 && !!j && j.agentParams.model === c.want && AGENT_TOOL_MODEL_ENUM.includes(j.agentParams.model),
+    'status=' + r.status + ' model=' + (j && j.agentParams && j.agentParams.model) + ' | ' + (r.stderr || '').slice(-200));
+  check(`map ${label}: granularityLoss=${c.loss} + stderr ${c.loss ? 'note' : 'silence'}`,
+    !!j && !!j.modelTranslation && j.modelTranslation.granularityLoss === c.loss &&
+    (r.stderr || '').includes('NOT expressible') === c.loss,
+    (j && JSON.stringify(j.modelTranslation)) + ' | ' + (r.stderr || '').slice(-200));
+}
+
+// ── [8] TASK_1815 unmappable claude model: loud failure, never a silent guess ─
+setModels({ dispatchModel: 'claude-nova-9', dispatchFamily: 'claude' });
+{
+  const r = dispatchSub();
+  check('unmappable model: non-zero exit', r.status !== 0, 'status=' + r.status);
+  check('unmappable model: no agentParams on stdout', !(r.stdout || '').includes('agentParams'), (r.stdout || '').slice(0, 200));
+  check('unmappable model: loud stderr (refusing to silently guess)',
+    (r.stderr || '').includes("dispatchModel 'claude-nova-9' cannot be mapped") &&
+    (r.stderr || '').includes('refusing to silently guess'), (r.stderr || '').slice(-400));
+  check('unmappable model: remediation points to Formation dispatch (kenaz_dispatch)',
+    (r.stderr || '').includes('kenaz_dispatch'), (r.stderr || '').slice(-400));
+}
+
+// ── [9]-[11] TASK_2032: subagent dispatch activates the card like the ────────
+// formation path (headless.js ~L272-290) does — a card must not sit in
+// backlog/ while the subagent works, or the eventual `task-api move <id>
+// done` is rejected ("backlog -> done not allowed").
+function taskStatusDir(id) {
+  for (const d of ['backlog', 'active', 'done', 'blocked', 'cancel']) {
+    const dir = path.join(SB, '.kenaz', 'tasks', d);
+    if (!fs.existsSync(dir)) continue;
+    if (fs.readdirSync(dir).some((f) => f.startsWith(id + '_') || f.startsWith(id + '.'))) return d;
+  }
+  return null;
+}
+function mkSandboxTask(title, scopePath) {
+  const mk = run(TASKAPI, ['--project-path', SB, 'create', '--title', title,
+    '--description', title, '--scope-paths', scopePath,
+    '--requirements', 'r1', '--acceptance-criteria', 'a1', '--acceptance-criteria', 'a2', '--acceptance-criteria', 'a3',
+    '--technical-notes', 't1', '--technical-notes', 't2', '--force']);
+  return ((mk.stdout || '').match(/TASK_\d+/) || [])[0];
+}
+
+// ── [9] regression: a successful subagent dispatch moves backlog -> active ──
+// This is the NEGATIVE CONTROL assertion: it FAILS on pre-fix dispatch.js
+// (the card is left in backlog/ while the subagent works) and PASSES after
+// the fix (dispatch.js moves it to active/ once every gate has passed).
+setModels({ dispatchModel: 'claude-fable-5', dispatchFamily: 'claude' });
+const TASK_ID_9 = mkSandboxTask('t2032 activate target', 'zzz/t2032.js');
+check('t2032 setup: sandbox backlog task created', !!TASK_ID_9, TASK_ID_9);
+check('t2032 setup: starts in backlog', taskStatusDir(TASK_ID_9) === 'backlog', taskStatusDir(TASK_ID_9));
+
+const r9 = run(DISPATCH, ['--skill=do', '--task=' + TASK_ID_9, '--dispatch-mode=subagent', '--project-path', SB]);
+check('t2032: dispatch succeeds (exit 0)', r9.status === 0, 'status=' + r9.status + ' | ' + (r9.stderr || '').slice(-300));
+check('t2032: card moved backlog -> active (NEGATIVE CONTROL — see task report for pre-fix FAIL output)',
+  taskStatusDir(TASK_ID_9) === 'active', 'dir=' + taskStatusDir(TASK_ID_9) + ' | stderr=' + (r9.stderr || '').slice(-300));
+check('t2032: stdout stayed pure JSON (activation logging did not leak to stdout)',
+  (() => { try { return !!JSON.parse(r9.stdout).agentParams; } catch { return false; } })(), (r9.stdout || '').slice(0, 200));
+
+// ── [10] a card already in active stays active, dispatch does not error ─────
+const r10 = run(DISPATCH, ['--skill=do', '--task=' + TASK_ID_9, '--dispatch-mode=subagent', '--project-path', SB]);
+check('t2032: re-dispatch of an already-active card still exits 0', r10.status === 0, 'status=' + r10.status + ' | ' + (r10.stderr || '').slice(-300));
+check('t2032: already-active card stays in active/ (no error, no unwanted move)', taskStatusDir(TASK_ID_9) === 'active', taskStatusDir(TASK_ID_9));
+
+// ── [11] a dispatch rejected by a gate leaves the card in backlog ───────────
+const TASK_ID_11 = mkSandboxTask('t2032 rejected target', 'zzz/t2032-reject.js');
+check('t2032 setup: second sandbox backlog task created', !!TASK_ID_11, TASK_ID_11);
+setModels({ dispatchModel: 'gpt-5-codex', dispatchFamily: 'bifrost', dispatchAdapter: 'openai' }); // rejected by the 2b routing guard, before activation ever runs
+const r11 = run(DISPATCH, ['--skill=do', '--task=' + TASK_ID_11, '--dispatch-mode=subagent', '--project-path', SB]);
+check('t2032: gate-rejected dispatch exits non-zero', r11.status !== 0, 'status=' + r11.status);
+check('t2032: gate-rejected dispatch leaves the card in backlog/', taskStatusDir(TASK_ID_11) === 'backlog', taskStatusDir(TASK_ID_11));
+
+fs.rmSync(SB, { recursive: true, force: true });
+console.log('---');
+console.log('RESULT: ' + pass + ' pass, ' + fail + ' fail');
+process.exit(fail ? 1 : 0);

package/core/.formation/tools/__tests__/subagent-codex-harness.test.js

@@ -0,0 +1,96 @@
+// TASK_2315: --harness=codex sub-agent payload (Codex-native spawn_agent) + refusal controls.
+// Usage: node .formation/tools/__tests__/subagent-codex-harness.test.js   (exit 0 = all pass)
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function resolveRoot() {
+  let d = path.resolve(__dirname);
+  for (let i = 0; i < 10; i++) {
+    if (fs.existsSync(path.join(d, '.kenaz')) && fs.existsSync(path.join(d, '.formation'))) return d;
+    const p = path.dirname(d); if (p === d) break; d = p;
+  }
+  throw new Error('Cannot resolve repo root from ' + __dirname);
+}
+const WT = resolveRoot();
+const SB = path.join(os.tmpdir(), 't2315_codex_' + process.pid);
+const TASKAPI = path.join(WT, '.collaboration/core/task-api.js');
+const DISPATCH = path.join(WT, '.formation/tools/dispatch.js');
+const MODELS = path.join(SB, '.kenaz', 'dashboard-models.json');
+const env = { ...process.env };
+delete env.CLAUDE_PROJECT_DIR; delete env.CODEX_SESSION_ID; delete env.CODEX_THREAD_ID;
+
+for (const d of ['.kenaz/tasks/backlog', '.kenaz/tasks/active', '.kenaz/tasks/done', '.kenaz/tasks/blocked', '.kenaz/tasks/cancel', '.kenaz/locks']) {
+  fs.mkdirSync(path.join(SB, d), { recursive: true });
+}
+const run = (script, args, opts) => spawnSync(process.execPath, [script, ...args], Object.assign({ encoding: 'utf8', env, windowsHide: true, cwd: WT }, opts || {}));
+const sbGit = (args) => spawnSync('git', args, { cwd: SB, encoding: 'utf8', windowsHide: true });
+let pass = 0, fail = 0;
+const check = (name, cond, detail) => { console.log((cond ? 'PASS' : 'FAIL') + ' | ' + name + (cond ? '' : ' | ' + detail)); cond ? pass++ : fail++; };
+
+// Real git repo so the worktree route is exercised (non-git targets get direct_no_git).
+fs.writeFileSync(path.join(SB, 'README.md'), 'x');
+fs.writeFileSync(path.join(SB, '.gitignore'), '.formation/worktrees/\n.kenaz/\n');
+sbGit(['init', '-q']); sbGit(['add', '-A']);
+sbGit(['-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '--no-verify', '-m', 'init']);
+
+const mk = run(TASKAPI, ['--project-path', SB, 'create', '--title', 't2315 codex target', '--description', 'codex harness test',
+  '--scope-paths', 'zzz/codex.js', '--requirements', 'r1', '--acceptance-criteria', 'a1', '--acceptance-criteria', 'a2', '--acceptance-criteria', 'a3',
+  '--technical-notes', 't1', '--technical-notes', 't2', '--force']);
+const TASK_ID = ((mk.stdout || '').match(/TASK_\d+/) || [])[0];
+check('setup: sandbox task created', !!TASK_ID, (mk.stdout || '') + (mk.stderr || ''));
+
+const setModels = (o) => fs.writeFileSync(MODELS, JSON.stringify(o, null, 2));
+const dispatch = (extra, e) => run(DISPATCH, ['--skill=do', '--task=' + TASK_ID, '--dispatch-mode=subagent', '--project-path', SB, ...extra], e ? { env: { ...env, ...e } } : undefined);
+const parse = (r) => { try { return JSON.parse(r.stdout); } catch { return null; } };
+const locksDir = path.join(SB, '.kenaz', 'locks');
+
+// [1] dry-run codex + bifrost: payload, no locks, no worktree, no agentParams
+setModels({ dispatchModel: 'gpt-5-codex', dispatchFamily: 'bifrost', dispatchAdapter: 'openai' });
+{
+  const r = dispatch(['--harness=codex', '--dry-run']); const j = parse(r);
+  check('codex dry-run: exit 0', r.status === 0, 'status=' + r.status + ' ' + (r.stderr || '').slice(-300));
+  check('codex dry-run: harness codex + promptText', !!j && j.harness === 'codex' && !!j.promptText, (r.stdout || '').slice(0, 200));
+  check('codex dry-run: no agentParams / no model', !!j && j.agentParams === undefined && !(r.stdout || '').includes('"agentParams"'), (r.stdout || '').slice(0, 200));
+  check('codex dry-run: modelTranslation inherited', !!j && j.modelTranslation.inherited === true && j.modelTranslation.requested === 'gpt-5-codex' && !('agentToolModel' in j.modelTranslation), j && JSON.stringify(j.modelTranslation));
+  check('codex dry-run: worktree path present but not created', !!j && /task_/.test(j.worktreePath || '') && j.cwd === j.worktreePath && !fs.existsSync(String(j.worktreePath).split(' (')[0]), j && j.worktreePath);
+  check('codex dry-run: no lock files', fs.readdirSync(locksDir).length === 0, fs.readdirSync(locksDir).join(','));
+  check('codex dry-run: card stays in backlog', fs.readdirSync(path.join(SB, '.kenaz/tasks/backlog')).some((f) => f.startsWith(TASK_ID)), 'moved');
+}
+
+// [2] env auto-detect (no --harness flag)
+{
+  const r = dispatch(['--dry-run'], { CODEX_THREAD_ID: 'abc' }); const j = parse(r);
+  check('auto-detect CODEX_THREAD_ID -> codex', r.status === 0 && !!j && j.harness === 'codex', (r.stderr || '').slice(-200));
+}
+
+// [3] real run: worktree actually created and referenced in the prompt
+{
+  const r = dispatch(['--harness=codex']); const j = parse(r);
+  check('codex real: exit 0 + worktree exists', r.status === 0 && !!j && !!j.worktreePath && fs.existsSync(j.worktreePath), 'status=' + r.status + ' ' + (r.stderr || '').slice(-300));
+  check('codex real: prompt names the worktree', !!j && j.promptText.includes(j.worktreePath), 'prompt lacks worktree');
+  check('codex real: isolation.mode target_repo_worktree', !!j && j.isolation.mode === 'target_repo_worktree', j && JSON.stringify(j.isolation));
+}
+
+// [4] negative controls
+{
+  const r = dispatch(['--harness=claude']);
+  check('claude harness + bifrost: still refuses (unchanged message)', r.status !== 0 && (r.stderr || '').includes('refusing to silently dispatch with the native Claude CLI') && !(r.stdout || '').includes('agentParams'), 'status=' + r.status + ' ' + (r.stderr || '').slice(-300));
+  const d = dispatch([]);
+  check('default harness (no flag) + bifrost: refuses', d.status !== 0, 'status=' + d.status);
+}
+setModels({ dispatchModel: 'claude-sonnet-4-6', dispatchFamily: 'claude' });
+{
+  const r = dispatch(['--harness=codex', '--dry-run']);
+  const rj = parse(r); // 2026-10-10: harness decides the family; a Codex session cannot run Claude models anyway
+  check('codex harness + claude family: codex payload, model inherited', r.status === 0 && !!rj && rj.harness === 'codex' && !rj.agentParams && !!rj.promptText, 'status=' + r.status + ' ' + (r.stderr || '').slice(-300));
+  const c = dispatch(['--harness=claude', '--dry-run']); const j = parse(c);
+  check('claude harness + claude family: unchanged agentParams.model', c.status === 0 && !!j && !!j.agentParams && j.agentParams.model === 'sonnet' && !j.harness, (c.stderr || '').slice(-200));
+  const bad = dispatch(['--harness=gemini', '--dry-run']);
+  check('unknown harness: refuses', bad.status !== 0, 'status=' + bad.status);
+}
+
+try { sbGit(['worktree', 'prune']); fs.rmSync(SB, { recursive: true, force: true }); } catch { /* best effort */ }
+console.log(`\n${pass} passed, ${fail} failed`);
+process.exit(fail ? 1 : 0);

package/core/.formation/tools/__tests__/task-1863-claim-late-release.test.js

@@ -0,0 +1,160 @@
+// TASK_1863 — dispatch claim-marker late-failure release + conversation-anchored
+// self-recognition in the same-task gate. Isolated sandbox (never touches the
+// real repo's .kenaz/locks or leases).
+//
+// Arms:
+//   A  (AC#1, injection): dispatch fails LATE (held serial dispatch lock) after the
+//      scope gate passed -> the self-owned claim marker must be RELEASED; the retry
+//      (lock freed) must not be blocked.
+//   B  (AC#1, incident shape): leaked claim owned by a LIVE ghost session alias but
+//      carrying OUR conversation id -> same-task guard must NOT block the retry.
+//   C  (AC#3, control): claim owned by a live foreign session with a DIFFERENT
+//      conversation id -> same-task guard MUST still block, marker MUST survive.
+//
+// Usage: node .formation/tools/__tests__/task-1863-claim-late-release.test.js
+// Exit 0=all pass, non-zero=at least one failure.
+
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function resolveRoot() {
+  var d = path.resolve(__dirname);
+  for (var i = 0; i < 10; i++) {
+    if (fs.existsSync(path.join(d, '.kenaz')) && fs.existsSync(path.join(d, '.formation'))) return d;
+    var parent = path.dirname(d); if (parent === d) break; d = parent;
+  }
+  if (process.env.CLAUDE_PROJECT_DIR) return process.env.CLAUDE_PROJECT_DIR;
+  throw new Error('Cannot resolve repo root from ' + __dirname);
+}
+const WT = resolveRoot();
+const SB = path.join(os.tmpdir(), 't1863_claim_' + process.pid);
+const TASKAPI = path.join(WT, '.collaboration/core/task-api.js');
+const DISPATCH = path.join(WT, '.formation/tools/dispatch.js');
+const STREAM_LEASE = path.join(WT, '.specialist/tools/stream-lease.js');
+
+const CONV = 'conv-t1863-main';
+const env = { ...process.env };
+delete env.CLAUDE_PROJECT_DIR;
+env.CLAUDE_CODE_SESSION_ID = CONV; // own conversation anchor (stable identity)
+
+for (const d of [
+  '.kenaz/tasks/backlog', '.kenaz/tasks/active', '.kenaz/tasks/done',
+  '.kenaz/tasks/blocked', '.kenaz/tasks/cancel',
+  '.kenaz/specialist/sessions/leases', '.kenaz/locks', '.specialist/tools',
+  '.git', // presence makes cross-project isolation resolve to serial_lock with --use-worktree=false
+]) fs.mkdirSync(path.join(SB, d), { recursive: true });
+fs.copyFileSync(STREAM_LEASE, path.join(SB, '.specialist/tools/stream-lease.js'));
+
+// Own identity: session ts1, conversation CONV
+const writeOwnStream = () => fs.writeFileSync(path.join(SB, '.kenaz/specialist/current_stream.json'),
+  JSON.stringify({ session_id: 'ts1', label: 'stream-A', pid: process.pid, conversation_id: CONV }));
+writeOwnStream();
+
+// Serial dispatch lock lives in CORE .formation (here: the repo we run from)
+const lockKey = (SB).replace(/[\\/:]/g, '_').toLowerCase();
+const LOCKFILE = path.join(WT, '.formation', '.dispatch-lock-' + lockKey);
+const clearLock = () => { try { fs.unlinkSync(LOCKFILE); } catch { /* absent */ } };
+
+const run = (script, args) =>
+  spawnSync(process.execPath, [script, ...args], { encoding: 'utf8', env, windowsHide: true, cwd: WT });
+const api = (args) => run(TASKAPI, ['--project-path', SB, ...args]);
+const disp = (taskId) => run(DISPATCH,
+  ['--skill=do', '--task=' + taskId, '--dispatch-mode=subagent', '--use-worktree=false', '--project-path', SB]);
+const markerPath = (id) => path.join(SB, '.kenaz/locks/claim_' + id + '.json');
+const leasePath = (sid) => path.join(SB, '.kenaz/specialist/sessions/leases/' + sid + '.json');
+const writeLiveLease = (sid, label) => fs.writeFileSync(leasePath(sid), JSON.stringify({
+  session_id: sid, pid: 9999999, conversation_id: null, label,
+  started_at: new Date().toISOString(), heartbeat_at: new Date().toISOString(),
+  claimed_tasks: [], scope_leases: [], resource_leases: [], phase: null,
+}, null, 2));
+
+let pass = 0, fail = 0;
+const check = (name, cond, detail) => {
+  console.log((cond ? 'PASS' : 'FAIL') + ' | ' + name + (cond ? '' : ' | ' + detail));
+  cond ? pass++ : fail++;
+};
+
+const mk = (title, scope) => {
+  const r = api(['create', '--title', title, '--description', 'sandbox task', '--scope-paths', scope,
+    '--requirements', 'r1', '--acceptance-criteria', 'a1', '--acceptance-criteria', 'a2', '--acceptance-criteria', 'a3',
+    '--technical-notes', 't1', '--technical-notes', 't2', '--force']);
+  const m = (r.stdout || '').match(/TASK_\d+/);
+  if (!m) throw new Error('task create failed: ' + (r.stdout || '') + (r.stderr || ''));
+  return m[0];
+};
+
+// ── Arm A: injected LATE failure releases the self-owned claim; retry passes ──
+const A = mk('t1863 A', 'zzz/a.js');
+api(['move', A, 'active', '--force']); // pre-claim by the chain (owner ts1 / CONV)
+check('A0 setup: claim marker written by move->active', fs.existsSync(markerPath(A)), 'no marker');
+
+// inject the late failure: hold the serial dispatch lock (fresh, foreign session)
+clearLock();
+fs.mkdirSync(path.dirname(LOCKFILE), { recursive: true });
+fs.writeFileSync(LOCKFILE, JSON.stringify({
+  sessionId: 'foreign-holder', taskId: 'TASK_0000', pid: null,
+  holder: 'subagent-shared-tree', startedAt: new Date().toISOString(),
+}));
+const a1 = disp(A);
+const a1All = (a1.stdout || '') + (a1.stderr || '');
+check('A1 attempt#1 fails late on held dispatch lock (exit!=0)',
+  a1.status !== 0 && a1All.includes('dispatch lock'), 'status=' + a1.status + ' | ' + a1All.slice(-400));
+check('A2 late failure RELEASES self-owned claim marker', !fs.existsSync(markerPath(A)),
+  'claim marker leaked: ' + markerPath(A));
+// retry: free the injected lock -> must not be blocked by anything
+clearLock();
+const a2 = disp(A);
+const a2All = (a2.stdout || '') + (a2.stderr || '');
+check('A3 attempt#2 (retry) is NOT blocked',
+  a2.status === 0 && !a2All.includes('scope conflict') && !a2All.includes('dispatch blocked') &&
+  (a2.stdout || '').includes('"promptText"'),
+  'status=' + a2.status + ' | ' + a2All.slice(-400));
+clearLock();
+
+// ── Arm B: leaked claim under a live ghost-session ALIAS of our conversation ──
+const B = mk('t1863 B', 'zzz/b.js');
+api(['move', B, 'active', '--force']);
+// simulate the 2026-08-13 incident: marker attributed to a ghost boot session
+// (live lease) but carrying OUR conversation id
+fs.writeFileSync(markerPath(B), JSON.stringify({
+  owner_session: 'ghostD', owner_conversation_id: CONV, owner_pid: 9999999,
+  claimed_at: new Date().toISOString(), dispatch_path: null,
+}, null, 2));
+writeLiveLease('ghostD', 'stream-D');
+const b1 = disp(B);
+const b1All = (b1.stdout || '') + (b1.stderr || '');
+check('B1 retry NOT blocked by own-conversation claim under ghost alias',
+  b1.status === 0 && !b1All.includes('same-task') && !b1All.includes('scope conflict'),
+  'status=' + b1.status + ' | ' + b1All.slice(-400));
+clearLock();
+fs.unlinkSync(leasePath('ghostD'));
+try { fs.unlinkSync(markerPath(B)); } catch { /* released by dispatch */ }
+
+// ── Arm C (control):真 foreign claim (different conversation) still blocks ──
+const C = mk('t1863 C', 'zzz/c.js');
+api(['move', C, 'active', '--force']);
+fs.writeFileSync(markerPath(C), JSON.stringify({
+  owner_session: 'ghostE', owner_conversation_id: 'conv-OTHER-session', owner_pid: 9999999,
+  claimed_at: new Date().toISOString(), dispatch_path: null,
+}, null, 2));
+writeLiveLease('ghostE', 'stream-E');
+const c1 = disp(C);
+const c1All = (c1.stdout || '') + (c1.stderr || '');
+check('C1 control: foreign live claim on same task STILL BLOCKS',
+  c1.status !== 0 && (c1All.includes('same-task') || c1All.includes('scope conflict')),
+  'status=' + c1.status + ' | ' + c1All.slice(-400));
+check('C2 control: foreign claim marker is NEVER released', fs.existsSync(markerPath(C)),
+  'foreign marker deleted — release is not self-scoped!');
+
+// differential sanity: A/B (not blocked) vs C (blocked) must differ
+check('D1 differential: self arms and control arm produce OPPOSITE outcomes',
+  a2.status === 0 && b1.status === 0 && c1.status !== 0,
+  'a2=' + a2.status + ' b1=' + b1.status + ' c1=' + c1.status);
+
+clearLock();
+fs.rmSync(SB, { recursive: true, force: true });
+console.log('---');
+console.log('RESULT: ' + pass + ' pass, ' + fail + ' fail');
+process.exit(fail ? 1 : 0);

package/core/.formation/tools/__tests__/task-2265-singleton-identity.test.js

@@ -0,0 +1,134 @@
+// TASK_2265 — singleton current_stream.json must never act as "self" identity.
+// Isolated sandbox (never touches the real repo's locks/leases/current_stream).
+//   A  claim writer: two conversations, current_stream names B -> A's claim is owned by A (hmap), not B
+//   A2 claim writer: env conv unbound + singleton names a FOREIGN conversation -> no marker (worker skip)
+//   A3 control: unbound env conv + singleton naming OUR conversation -> fallback id still used
+//   B  scope gate: unproven identity (singleton = foreign live session) must still see that session's claim
+//   B2 control: hmap-proven own identity + own claim -> not blocked
+//   C  dispatch lock writer: unproven -> sessionId 'unknown'; proven -> hmap boot_sid
+// Usage: node .formation/tools/__tests__/task-2265-singleton-identity.test.js
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function resolveRoot() {
+  var d = path.resolve(__dirname);
+  for (var i = 0; i < 10; i++) {
+    if (fs.existsSync(path.join(d, '.kenaz')) && fs.existsSync(path.join(d, '.formation'))) return d;
+    var parent = path.dirname(d); if (parent === d) break; d = parent;
+  }
+  throw new Error('Cannot resolve repo root from ' + __dirname);
+}
+const WT = resolveRoot();
+const SB = path.join(os.tmpdir(), 't2265_' + process.pid);
+const TASKAPI = path.join(WT, '.collaboration/core/task-api.js');
+const DISPATCH = path.join(WT, '.formation/tools/dispatch.js');
+
+for (const d of ['.kenaz/tasks/backlog', '.kenaz/tasks/active', '.kenaz/tasks/done', '.kenaz/tasks/blocked',
+  '.kenaz/tasks/cancel', '.kenaz/specialist/sessions/leases', '.kenaz/locks', '.specialist/tools', '.claude/hooks', '.git'])
+  fs.mkdirSync(path.join(SB, d), { recursive: true });
+fs.copyFileSync(path.join(WT, '.specialist/tools/stream-lease.js'), path.join(SB, '.specialist/tools/stream-lease.js'));
+fs.copyFileSync(path.join(WT, '.claude/hooks/_session-identity.js'), path.join(SB, '.claude/hooks/_session-identity.js'));
+
+const lockKey = SB.replace(/[\\/:]/g, '_').toLowerCase();
+const LOCKFILE = path.join(WT, '.formation', '.dispatch-lock-' + lockKey);
+const clearLock = () => { try { fs.unlinkSync(LOCKFILE); } catch { /* absent */ } };
+
+const stream = (sid, cid) => fs.writeFileSync(path.join(SB, '.kenaz/specialist/current_stream.json'),
+  JSON.stringify({ session_id: sid, label: 'L-' + sid, pid: process.pid, ...(cid ? { conversation_id: cid } : {}) }));
+const hmap = (conv, sid) => fs.writeFileSync(path.join(SB, '.kenaz/specialist/sessions/hmap_' + conv + '.json'),
+  JSON.stringify({ boot_sid: sid }));
+const lease = (sid, conv) => fs.writeFileSync(path.join(SB, '.kenaz/specialist/sessions/leases/' + sid + '.json'), JSON.stringify({
+  session_id: sid, pid: 9999999, conversation_id: conv || null, label: 'L-' + sid,
+  started_at: new Date().toISOString(), heartbeat_at: new Date().toISOString(),
+  claimed_tasks: [], scope_leases: [], resource_leases: [], phase: null }, null, 2));
+const envFor = (conv) => { const e = { ...process.env }; delete e.CLAUDE_PROJECT_DIR; delete e.CLAUDE_CODE_SESSION_ID; if (conv) e.CLAUDE_CODE_SESSION_ID = conv; return e; };
+const run = (script, args, conv) => spawnSync(process.execPath, [script, ...args], { encoding: 'utf8', env: envFor(conv), windowsHide: true, cwd: WT });
+const api = (args, conv) => run(TASKAPI, ['--project-path', SB, ...args], conv);
+const disp = (taskId, conv) => run(DISPATCH, ['--skill=do', '--task=' + taskId, '--dispatch-mode=subagent', '--use-worktree=false', '--project-path', SB], conv);
+const marker = (id) => { try { return JSON.parse(fs.readFileSync(path.join(SB, '.kenaz/locks/claim_' + id + '.json'), 'utf8')); } catch { return null; } };
+
+let pass = 0, fail = 0;
+const check = (name, cond, detail) => { console.log((cond ? 'PASS' : 'FAIL') + ' | ' + name + (cond ? '' : ' | ' + detail)); cond ? pass++ : fail++; };
+const mk = (title, scope) => {
+  const r = api(['create', '--title', title, '--description', 'sandbox task', '--scope-paths', scope, '--requirements', 'r1',
+    '--acceptance-criteria', 'a1', '--acceptance-criteria', 'a2', '--acceptance-criteria', 'a3',
+    '--technical-notes', 't1', '--technical-notes', 't2', '--force'], 'conv-setup');
+  const m = (r.stdout || '').match(/TASK_\d+/);
+  if (!m) throw new Error('task create failed: ' + (r.stdout || '') + (r.stderr || ''));
+  return m[0];
+};
+
+try {
+  // ── A: two conversations; the singleton names B, A claims ──
+  hmap('convA', 'sA'); hmap('convB', 'sB'); lease('sA', 'convA'); lease('sB', 'convB');
+  stream('sB', 'convB');
+  const A = mk('t2265 A', 'zzz/a.js');
+  api(['move', A, 'active', '--force'], 'convA');
+  const ma = marker(A);
+  check('A1 claim by conv A names A (hmap), not the singleton B', ma && ma.owner_session === 'sA' && ma.owner_conversation_id === 'convA', JSON.stringify(ma));
+  const A2 = mk('t2265 A2', 'zzz/a2.js');
+  api(['move', A2, 'active', '--force'], 'convB');
+  const mb = marker(A2);
+  check('A1b control: conv B claim names B', mb && mb.owner_session === 'sB' && mb.owner_conversation_id === 'convB', JSON.stringify(mb));
+
+  // ── A2: unbound env conv, singleton names a foreign conversation -> no wrong-owner marker ──
+  const U = mk('t2265 U', 'zzz/u.js');
+  api(['move', U, 'active', '--force'], 'convUnbound');
+  check('A2 unbound conv + foreign singleton: no marker written', marker(U) === null, JSON.stringify(marker(U)));
+  // A3 control: singleton names OUR conversation -> fallback still used
+  stream('sU', 'convUnbound');
+  const U2 = mk('t2265 U2', 'zzz/u2.js');
+  api(['move', U2, 'active', '--force'], 'convUnbound');
+  const mu = marker(U2);
+  check('A3 control: unbound conv + singleton naming own conv: fallback id used', mu && mu.owner_session === 'sU' && mu.owner_conversation_id === 'convUnbound', JSON.stringify(mu));
+
+  // ── B: scope gate fail-open. Foreign live session F holds a claim on T; singleton names F; our conv unbound ──
+  stream('sF', 'convF'); lease('sF', 'convF');
+  const T = mk('t2265 T', 'zzz/t.js');
+  fs.writeFileSync(path.join(SB, '.kenaz/locks/claim_' + T + '.json'), JSON.stringify({
+    owner_session: 'sF', owner_conversation_id: 'convF', owner_pid: 9999999, claimed_at: new Date().toISOString() }));
+  clearLock();
+  const b1 = disp(T, 'convMe'); // convMe unbound; singleton = sF (foreign)
+  const b1All = (b1.stdout || '') + (b1.stderr || '');
+  check('B1 unproven identity: foreign live claim still blocks (same-task)', b1.status !== 0 && /blocked|scope conflict/i.test(b1All), 'status=' + b1.status + ' | ' + b1All.slice(-300));
+  check('B1b foreign marker survives', marker(T) && marker(T).owner_session === 'sF', JSON.stringify(marker(T)));
+  clearLock();
+
+  // ── B2 control: proven own identity + own claim (hmap) -> not blocked ──
+  hmap('convMe', 'sMe'); lease('sMe', 'convMe'); stream('sMe', 'convMe');
+  const O = mk('t2265 O', 'zzz/o.js');
+  api(['move', O, 'active', '--force'], 'convMe');
+  clearLock();
+  const b2 = disp(O, 'convMe');
+  check('B2 control: proven own claim not blocked', b2.status === 0 && (b2.stdout || '').includes('"promptText"'), 'status=' + b2.status + ' | ' + ((b2.stdout || '') + (b2.stderr || '')).slice(-300));
+
+  // ── C: dispatch lock writer (reads identity from the CORE root = WT, so save/restore WT files) ──
+  const readHolder = () => { try { return JSON.parse(fs.readFileSync(LOCKFILE, 'utf8')); } catch { return null; } };
+  const WCS = path.join(WT, '.kenaz/specialist/current_stream.json');
+  const WH = path.join(WT, '.kenaz/specialist/sessions/hmap_convP2265.json');
+  const keep = (f) => { try { return fs.readFileSync(f, 'utf8'); } catch { return null; } };
+  const restore = (f, v) => { try { v === null ? fs.unlinkSync(f) : fs.writeFileSync(f, v); } catch { /* best effort */ } };
+  const prevCS = keep(WCS), prevH = keep(WH);
+  try {
+    fs.mkdirSync(path.dirname(WH), { recursive: true });
+    fs.writeFileSync(WCS, JSON.stringify({ session_id: 'sForeignCore', pid: process.pid }));
+    fs.writeFileSync(WH, JSON.stringify({ boot_sid: 'sProvenCore' }));
+    const O2 = mk('t2265 O2', 'zzz/o2.js');
+    clearLock();
+    const c2 = disp(O2, 'convUnbound2');
+    check('C1 unproven: dispatch ok', c2.status === 0, 'status=' + c2.status + ' | ' + ((c2.stdout || '') + (c2.stderr || '')).slice(-300));
+    check('C1 unproven: lock holder sessionId = unknown (never the singleton)', (readHolder() || {}).sessionId === 'unknown', JSON.stringify(readHolder()));
+    clearLock();
+    const O3 = mk('t2265 O3', 'zzz/o3.js');
+    const c3 = disp(O3, 'convP2265');
+    check('C2 control: proven (hmap) lock holder sessionId = boot_sid', c3.status === 0 && (readHolder() || {}).sessionId === 'sProvenCore', 'status=' + c3.status + ' | ' + JSON.stringify(readHolder()));
+  } finally { restore(WCS, prevCS); restore(WH, prevH); }
+} finally {
+  clearLock();
+  try { fs.rmSync(SB, { recursive: true, force: true }); } catch { /* best effort */ }
+}
+console.log('---');
+console.log('RESULT: ' + pass + ' pass, ' + fail + ' fail');
+process.exit(fail ? 1 : 0);