kenaz 0.0.0-stage → 0.3.2

package/core/.formation/bifrost/openai/relay.test.js

@@ -0,0 +1,71 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { EventEmitter } = require('node:events');
+
+async function fixture(project, resume = false) {
+  const cwd = path.resolve('execution-worktree');
+  const effects = { tees: [], stops: [], spawns: [], exits: [] };
+  const child = new EventEmitter();
+  child.stdin = { write() {}, end() {} };
+  child.stdout = new EventEmitter();
+  child.stderr = new EventEmitter();
+  const tee = { write() {} };
+  const module = { exports: {} };
+  const context = { __dirname, module, Buffer, console,
+    process: { argv: ['node', 'relay.js', '--cwd', cwd, ...(resume ? ['--resume', 'thread-123'] : [])],
+      env: { CODEX_NATIVE_HOOKS_ACTIVE: '1', ...(project ? { KENAZ_CONSOLIDATE_ROOT: project } : {}) },
+      cwd: () => path.resolve('process-cwd'), platform: 'linux',
+      stdin: { async *[Symbol.asyncIterator]() { yield Buffer.from('fixture prompt'); } },
+      stderr: { write() {} }, stdout: { write() {} }, exit: code => effects.exits.push(code) },
+    require(id) {
+      if (id === 'path') return path;
+      if (id === 'fs') return { readFileSync: () => '{}' };
+      if (id === 'child_process') return { spawn: (...args) => { effects.spawns.push(args); return child; } };
+      if (id.endsWith('task-bridge.js')) return { handleHookEvent: async () => {} };
+      if (id.endsWith('consolidate.js')) return {
+        createTranscriptTee: (root, session) => { effects.tees.push({ root, session }); return tee; },
+        runStopConsolidation: async options => { effects.stops.push(options); },
+      };
+      if (id.endsWith('setup-codex.js')) return {
+        ensureProjectMcpServers: () => ({ registered: [], refreshed: [], pruned: [] }),
+        probeProjectMcpServers: async () => {},
+      };
+      // TASK_2160: relay registers headless threads for codex_wake; inert here.
+      if (id.endsWith('codex-session-registry.js')) return { registerHeadless: () => {} };
+      assert.fail(`unexpected module: ${id}`);
+    },
+  };
+  vm.runInNewContext(fs.readFileSync(path.join(__dirname, 'relay.js'), 'utf8'), context);
+  await context.main();
+  await child.listeners('close')[0](0);
+  return { effects, cwd, tee };
+}
+
+test('concurrent relay transcript and Stop use pinned roots while execution cwd stays unchanged', async () => {
+  const projects = [path.resolve('project-A'), path.resolve('project-B')];
+  const results = await Promise.all(projects.map(project => fixture(project)));
+  results.forEach(({ effects, cwd, tee }, i) => {
+    assert.equal(effects.tees[0].root, projects[i]);
+    assert.equal(effects.stops[0].projectRoot, projects[i]);
+    assert.equal(effects.stops[0].tee, tee);
+    assert.equal(effects.spawns[0][2].cwd, cwd);
+    assert.equal(effects.spawns[0][2].env.CLAUDE_PROJECT_DIR, cwd);
+    assert.deepEqual(effects.exits, [0]);
+  });
+});
+
+test('standalone relay retains cwd fallback and resumed relay retains pinned state root', async () => {
+  const standalone = await fixture(null);
+  assert.equal(standalone.effects.tees[0].root, standalone.cwd);
+  assert.equal(standalone.effects.stops[0].projectRoot, standalone.cwd);
+  const project = path.resolve('resume-project');
+  const resumed = await fixture(project, true);
+  assert.equal(resumed.effects.tees[0].root, project);
+  assert.equal(resumed.effects.tees[0].session, 'thread-123');
+  assert.equal(resumed.effects.stops[0].projectRoot, project);
+  assert.equal(resumed.effects.stops[0].sessionId, 'thread-123');
+});

package/core/.formation/bifrost/session.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+/**
+ * Bifröst Session Launcher
+ *
+ * Assembles a Specialist prompt (Ansuz, Amelia, etc.) and routes it
+ * through a Bifröst adapter instead of Claude Code CLI.
+ *
+ * Usage:
+ *   node .formation/bifrost/session.js --specialist Ansuz --adapter openai
+ *   node .formation/bifrost/session.js --specialist Ansuz --adapter openai --model o3
+ *   node .formation/bifrost/session.js --specialist Ansuz --adapter openai --depth capsule
+ *
+ * This is the Bifröst equivalent of:
+ *   node .specialist/tools/session.js prompt Ansuz --mode=assembled --depth=capsule
+ *   (which injects into Claude Code)
+ *
+ * The specialist prompt is assembled by session.js (unchanged), then piped
+ * through the adapter relay. Cognitive tools (Synapse, Hippocampus, etc.)
+ * require Dashboard to be running.
+ */
+
+const { execSync, execFileSync, spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { renderCodexAntiDrift } = require('./shared/codex-injection');
+const { resolveBootPolicy } = require('./shared/ansuz-boot-policy');
+
+// task-bridge: required for Bifrost hook dispatch (TASK_1228 — CGDD phantom contract)
+// Require path from .formation/bifrost/session.js → .specialist/tools/task-bridge.js
+const { handleHookEvent } = require(path.resolve(__dirname, '../..', '.specialist/tools/task-bridge.js'));
+const { fetchBootContext } = require('./shared/boot-context');
+// TASK_1735: consolidation module (handoff + heartbeat on Stop; tee lives in relay subprocess)
+const { runStopConsolidation } = require('./shared/consolidate');
+
+// ─────────────────────────────────────────
+// Config
+// ─────────────────────────────────────────
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const args = parseArgs(process.argv.slice(2));
+
+const SPECIALIST = args.specialist || 'Ansuz';
+const ADAPTER = args.adapter || 'openai';
+const MODEL = args.model || null;
+// Same default as interactive launch.js: Ansuz → elixir (fast), other
+// specialists and explicit --depth unchanged. The old hard-coded 'kernel'
+// made headless Ansuz carry a ~115 KB prompt (kernel + self-model) that a
+// 2026-09-23 A/B measured at ~1.6x the tokens of elixir with no outcome gain
+// (dev/ANSUZ_STARTUP_INJECTION_REVIEW.md).
+const DEPTH = resolveBootPolicy({ specialist: SPECIALIST, depth: args.depth }).depth;
+const CWD = args.cwd || ROOT;
+const PROJECT_PATH = path.resolve(args.projectPath || CWD);
+const RESUME_ID = args.resume || null;  // thread_id for multi-turn resume
+const SIGNAL_PATH = path.join(ROOT, '.formation', '.bifrost-active');
+
+// ─────────────────────────────────────────
+// Step 1: Assemble Specialist Prompt
+// ─────────────────────────────────────────
+
+function assemblePrompt() {
+  const sessionScript = path.join(ROOT, '.specialist', 'tools', 'session.js');
+  if (!fs.existsSync(sessionScript)) {
+    console.error(`[bifrost] session.js not found at ${sessionScript}`);
+    process.exit(1);
+  }
+
+  console.error(`[bifrost] Assembling ${SPECIALIST} prompt (depth=${DEPTH})...`);
+
+  try {
+    const prompt = execFileSync(
+      process.execPath,
+      [sessionScript, 'prompt', SPECIALIST, '--mode=assembled', `--depth=${DEPTH}`, '--external-boot-context', '--project-path', PROJECT_PATH],
+      {
+        cwd: ROOT,
+        encoding: 'utf8',
+        timeout: 30000,
+        maxBuffer: 10 * 1024 * 1024,
+        windowsHide: true,
+        env: { ...process.env }
+      }
+    );
+    return prompt.trim();
+  } catch (err) {
+    console.error(`[bifrost] Failed to assemble prompt: ${err.message}`);
+    if (err.stderr) console.error(err.stderr);
+    process.exit(1);
+  }
+}
+
+// ─────────────────────────────────────────
+// Hook Dispatch Ownership (TASK_1227 contract)
+//
+// This file owns observation + normalization + dispatch for:
+//   SessionStart   — fired after writeSignal(), before launchRelay()
+//   UserPromptSubmit — fired after prompt assembly, before relay stdin write
+//   Stop           — fired in relay.on('close')
+//
+// Canonical payload schema: BIFROST_HOOK_LIFECYCLE in task-bridge.js
+// TASK_1228 implements SessionStart + UserPromptSubmit dispatch here.
+// TASK_1230 implements Stop dispatch here.
+// ─────────────────────────────────────────
+
+// Module-level timestamp set at SessionStart dispatch; referenced by Stop (TASK_1230).
+let sessionStartedAt = null;
+
+/**
+ * resolveProjectPath — local inline; mirrors task-bridge.js version.
+ * session.js cannot import from task-bridge to avoid circular call issues
+ * when building the payload before dispatch.
+ */
+function resolveProjectPath(cwd) {
+  return path.resolve(cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd());
+}
+
+/**
+ * dispatchBifrostHook — session.js (CGDD phantom: session_dispatchBifrostHook)
+ *
+ * Shared dispatch utility for all three session-owned events:
+ * SessionStart, UserPromptSubmit, Stop.
+ * Calls handleHookEvent() from task-bridge.js. Hook failures are caught
+ * and logged to stderr — they must never crash the session.
+ */
+function dispatchBifrostHook(eventName, payload) {
+  try {
+    // handleHookEvent is async; for UserPromptSubmit it executes synchronously
+    // (no awaits in that branch), so the promise resolves before relay.stdin.write.
+    handleHookEvent(payload).catch(err => {
+      process.stderr.write(`[bifrost] ${eventName} hook async error: ${err.message}\n`);
+    });
+    process.stderr.write(`[bifrost] hook fired: ${eventName} | specialist=${SPECIALIST} | session_id=${RESUME_ID || 'null'}\n`);
+  } catch (err) {
+    process.stderr.write(`[bifrost] ${eventName} hook error: ${err.message}\n`);
+  }
+}
+
+/**
+ * normalizeSessionStart — session.js (CGDD phantom: session_normalizeSessionStart)
+ *
+ * Shapes the canonical SessionStart payload from module-level constants.
+ */
+function normalizeSessionStart() {
+  return {
+    hook_event_name: 'SessionStart',
+    specialist:      SPECIALIST,
+    adapter:         ADAPTER,
+    model:           MODEL,
+    cwd:             CWD,
+    pid:             process.pid,
+    session_id:      RESUME_ID || null,
+    started_at:      new Date().toISOString(),
+    project_path:    PROJECT_PATH,
+  };
+}
+
+/**
+ * normalizeUserPromptSubmit — session.js (CGDD phantom: session_normalizeUserPromptSubmit)
+ *
+ * Shapes the canonical UserPromptSubmit payload.
+ * prompt + user_prompt + text aliases are ALL required for maybeEmitReminder compat.
+ */
+function normalizeUserPromptSubmit(prompt) {
+  return {
+    hook_event_name: 'UserPromptSubmit',
+    user_prompt:     prompt,
+    prompt:          prompt,   // compat alias — maybeEmitReminder reads payload.prompt
+    text:            prompt,   // secondary compat alias
+    specialist:      SPECIALIST,
+    session_id:      RESUME_ID || null,
+    cwd:             CWD,
+    project_path:    PROJECT_PATH,
+    submitted_at:    new Date().toISOString(),
+  };
+}
+
+/**
+ * normalizeStop — session.js (CGDD phantom: session_normalizeStop)
+ *
+ * Shapes the canonical Stop payload from relay close event data.
+ * Fired once in relay.on('close'), before process.exit().
+ *
+ * Usage data (total_cost_usd, num_turns, input_tokens, output_tokens) is NOT
+ * capturable here because relay stdout is inherited (not piped) — these fields
+ * default to 0 per the CGDD spec (all marked required: false).
+ *
+ * started_at is sourced from sessionStartedAt set at SessionStart dispatch time.
+ */
+function normalizeStop(exitCode) {
+  return {
+    hook_event_name: 'Stop',
+    specialist:      SPECIALIST,
+    adapter:         ADAPTER,
+    exit_code:       exitCode != null ? exitCode : 0,
+    is_error:        (exitCode != null && exitCode !== 0),
+    session_id:      RESUME_ID || null,
+    total_cost_usd:  0,   // not capturable — relay stdout is inherited
+    num_turns:       0,   // not capturable — relay stdout is inherited
+    input_tokens:    0,   // not capturable — relay stdout is inherited
+    output_tokens:   0,   // not capturable — relay stdout is inherited
+    started_at:      sessionStartedAt,
+    ended_at:        new Date().toISOString(),
+    cwd:             CWD,
+    project_path:    PROJECT_PATH,
+  };
+}
+
+// ─────────────────────────────────────────
+// Step 2: Route through Bifröst adapter
+// ─────────────────────────────────────────
+
+function launchRelay(prompt) {
+  const adapterDir = path.join(__dirname, ADAPTER);
+  const relayScript = path.join(adapterDir, 'relay.js');
+
+  if (!fs.existsSync(relayScript)) {
+    console.error(`[bifrost] Adapter not found: ${relayScript}`);
+    console.error(`[bifrost] Available adapters: ${listAdapters().join(', ')}`);
+    process.exit(1);
+  }
+
+  // TASK_1733: decide the native-hooks dedupe flag BEFORE spawning the relay so both
+  // (a) the relay child (inherits env — skips its own probe) and (b) this process
+  // see the same verdict.
+  if (!process.env.CODEX_NATIVE_HOOKS_ACTIVE) {
+    try {
+      const { nativeHooksActive } = require('./setup-codex');
+      if (nativeHooksActive(ROOT)) {
+        process.env.CODEX_NATIVE_HOOKS_ACTIVE = '1';
+        console.error('[bifrost] native codex hooks active — per-turn telemetry via shim; post-session proxy suppressed');
+      }
+    } catch { /* probe failure = keep post-session proxy */ }
+  }
+
+  const relayArgs = ['--cwd', CWD];
+  if (MODEL) relayArgs.push('--model', MODEL);
+  if (RESUME_ID) relayArgs.push('--resume', RESUME_ID);
+
+  const mode = RESUME_ID ? `RESUME ${RESUME_ID.slice(0, 12)}...` : 'NEW';
+  console.error(`[bifrost] Launching ${ADAPTER} relay | ${mode} | Model: ${MODEL || 'default'} | Specialist: ${SPECIALIST}`);
+  console.error(`[bifrost] Prompt size: ${prompt.length} chars (~${Math.round(prompt.length / 4)} tokens)`);
+
+  const relay = spawn('node', [relayScript, ...relayArgs], {
+    cwd: CWD,
+    env: { ...process.env, KENAZ_CONSOLIDATE_ROOT: PROJECT_PATH },
+    stdio: ['pipe', 'inherit', 'inherit'],  // stdout/stderr to parent
+    windowsHide: true
+  });
+
+  // Fire UserPromptSubmit hook before writing to relay stdin (TASK_1228)
+  // Ordering guarantee: hook fires (and maybeEmitReminder writes to stdout if triggered)
+  // before relay receives the prompt and before Codex starts generating its response.
+  dispatchBifrostHook('UserPromptSubmit', normalizeUserPromptSubmit(prompt));
+
+  // Pipe prompt to relay stdin
+  relay.stdin.write(prompt);
+  relay.stdin.end();
+
+  relay.on('close', async (code) => {
+    // ── Stop hook dispatch (TASK_1230) ──────────────────────────────────────
+    // Fires first — before process.exit().
+    // Ordering guarantee: Stop is always the last Bifrost lifecycle event.
+    // Specialist-side teardown integration point: session.js relay.on('close')
+    dispatchBifrostHook('Stop', normalizeStop(code));
+    // ───────────────────────────────────────────────────────────────────────
+
+    // TASK_1735: session-side stop consolidation (handoff + heartbeat).
+    // Tee lives in relay.js subprocess; session.js calls without tee (transcript
+    // already written by relay.js; this call updates handoff + appends heartbeat).
+    // fail-open: never blocks exit.
+    try { await runStopConsolidation({
+      projectRoot: PROJECT_PATH,
+      sessionId:   RESUME_ID || null,
+      topic:       SPECIALIST + ' session via Bifrost',
+      tee:         null,  // relay subprocess owns the transcript tee
+      port:        process.env.KENAZ_HTTP_PORT || '18080',
+    }); } catch (_ce) {}
+
+    cleanupSignal();
+    process.exit(code || 0);
+  });
+
+  relay.on('error', (err) => {
+    console.error(`[bifrost] Failed to spawn relay: ${err.message}`);
+    cleanupSignal();
+    process.exit(1);
+  });
+}
+
+function writeSignal() {
+  try {
+    fs.writeFileSync(
+      SIGNAL_PATH,
+      JSON.stringify({
+        adapter: ADAPTER,
+        specialist: SPECIALIST,
+        pid: process.pid,
+        started: new Date().toISOString(),
+        mode: RESUME_ID ? 'resume' : 'session',
+      })
+    );
+  } catch (err) {
+    console.error(`[bifrost] Failed to write signal file: ${err.message}`);
+  }
+}
+
+function cleanupSignal() {
+  try {
+    if (fs.existsSync(SIGNAL_PATH)) {
+      fs.unlinkSync(SIGNAL_PATH);
+    }
+  } catch {}
+}
+
+// ─────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────
+
+function listAdapters() {
+  const entries = fs.readdirSync(__dirname, { withFileTypes: true });
+  return entries
+    .filter(e => e.isDirectory() && e.name !== 'shared')
+    .map(e => e.name);
+}
+
+function parseArgs(argv) {
+  const result = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === '--specialist' && argv[i + 1]) {
+      result.specialist = argv[++i];
+    } else if (argv[i] === '--adapter' && argv[i + 1]) {
+      result.adapter = argv[++i];
+    } else if (argv[i] === '--model' && argv[i + 1]) {
+      result.model = argv[++i];
+    } else if (argv[i] === '--depth' && argv[i + 1]) {
+      result.depth = argv[++i];
+    } else if (argv[i] === '--cwd' && argv[i + 1]) {
+      result.cwd = argv[++i];
+    } else if (argv[i] === '--project-path' && argv[i + 1]) {
+      result.projectPath = argv[++i];
+    } else if (argv[i].startsWith('--project-path=')) {
+      result.projectPath = argv[i].slice('--project-path='.length);
+    } else if (argv[i] === '--resume' && argv[i + 1]) {
+      result.resume = argv[++i];
+    }
+  }
+  return result;
+}
+
+// ─────────────────────────────────────────
+// Main
+// ─────────────────────────────────────────
+
+// Resume mode: skip prompt assembly, just send the user's message
+if (RESUME_ID) {
+  writeSignal();
+  // Fire SessionStart hook after signal is written (TASK_1228)
+  const ssPayload = normalizeSessionStart();
+  sessionStartedAt = ssPayload.started_at;
+  dispatchBifrostHook('SessionStart', ssPayload);
+  // In resume mode, read prompt from remaining args or stdin
+  const userMsg = args._rest || 'Continue the session.';
+  launchRelay(userMsg);
+} else {
+  (async () => {
+    const kernelPrompt = assemblePrompt();
+    // Prepend Codex anti-drift protocols so headless dispatch sees the same
+    // guards as interactive launch.js. Without this, auto-loop dispatches run
+    // with zero Codex-specific reinforcement, which is what caused the 4/7-4/9
+    // accumulation of scope drift, attribution lies, and orphan worktrees.
+    // TASK_1734: prepend boot cognitive context (preamble + canary + handoff)
+    const bootCtx = await fetchBootContext({ specialist: SPECIALIST, projectRoot: ROOT, projectPath: PROJECT_PATH, includeCanary: false });
+    const prompt = bootCtx + renderCodexAntiDrift() + kernelPrompt;
+    writeSignal();
+    // Fire SessionStart hook after signal is written (TASK_1228)
+    const ssPayload = normalizeSessionStart();
+    sessionStartedAt = ssPayload.started_at;
+    dispatchBifrostHook('SessionStart', ssPayload);
+    launchRelay(prompt);
+  })();
+}
+
+process.on('SIGINT', () => { cleanupSignal(); process.exit(130); });
+process.on('SIGTERM', () => { cleanupSignal(); process.exit(143); });

package/core/.formation/bifrost/session.test.js

@@ -0,0 +1,121 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const { EventEmitter } = require('node:events');
+
+async function launchFixture(argv) {
+  const effects = { children: [], contexts: [], hooks: [], writes: [], spawns: [], prompts: [], stops: [], exits: [] };
+  const relay = new EventEmitter();
+  relay.stdin = { write: text => effects.prompts.push(text), end() {} };
+  const context = {
+    __dirname, console: { error() {} },
+    process: { argv: [process.execPath, 'session.js', ...argv], execPath: process.execPath,
+      env: { CODEX_NATIVE_HOOKS_ACTIVE: '1', KENAZ_CONSOLIDATE_ROOT: 'unrelated-env', RETAIN_ME: 'yes' }, pid: 1, cwd: () => path.resolve('process-cwd'),
+      stderr: { write() {} }, on() {}, exit: code => effects.exits.push(code) },
+    require(id) {
+      if (id === 'path') return path;
+      if (id === 'fs') return { existsSync: () => true, writeFileSync: (...args) => effects.writes.push(args), unlinkSync() {} };
+      if (id === 'child_process') return {
+        execSync: () => assert.fail('shell execution forbidden in prompt assembly'),
+        execFileSync: (file, args, options) => { effects.children.push({ file, args, options }); return 'fixture persona'; },
+        spawn: (...args) => { effects.spawns.push(args); return relay; },
+      };
+      if (id === './shared/codex-injection') return { renderCodexAntiDrift: () => 'fixture guard\n' };
+      if (id === './shared/ansuz-boot-policy') return require('./shared/ansuz-boot-policy');
+      if (id.endsWith('task-bridge.js')) return { handleHookEvent: async payload => { effects.hooks.push(payload); } };
+      if (id === './shared/boot-context') return { fetchBootContext: async options => {
+        effects.contexts.push(options); return `boot:${options.projectPath}\n`;
+      } };
+      if (id === './shared/consolidate') return { runStopConsolidation: async options => { effects.stops.push(options); } };
+      assert.fail(`unexpected module ${id}`);
+    },
+  };
+  vm.runInNewContext(fs.readFileSync(path.join(__dirname, 'session.js'), 'utf8'), context, { filename: 'session.js' });
+  await new Promise(resolve => setImmediate(resolve));
+  return { effects, stop: code => context.normalizeStop(code), close: async code => {
+    await relay.listeners('close')[0](code);
+  }, parentEnv: context.process.env };
+}
+
+test('headless explicit project wins cwd in both flag formats and remains a single safe argv', async () => {
+  const cwd = path.resolve('relay-cwd');
+  const project = path.resolve('selected project & $(literal)');
+  for (const flag of [['--project-path', project], [`--project-path=${project}`]]) {
+    const { effects, stop } = await launchFixture(['--cwd', cwd, ...flag]);
+    assert.equal(effects.children.length, 1);
+    const child = effects.children[0];
+    assert.equal(child.file, process.execPath);
+    assert.ok(child.args.includes('--external-boot-context'));
+    assert.deepEqual(Array.from(child.args.slice(-2)), ['--project-path', project]);
+    assert.equal(child.args[0], path.resolve(__dirname, '../../.specialist/tools/session.js'));
+    assert.equal(child.options.cwd, path.resolve(__dirname, '../..'));
+    assert.equal(effects.contexts[0].projectPath, project);
+    assert.equal(effects.contexts[0].includeCanary, false);
+    assert.equal(effects.contexts[0].projectRoot, child.options.cwd);
+    assert.equal(effects.spawns[0][2].cwd, cwd);
+    assert.ok(effects.prompts[0].includes(`boot:${project}`));
+    assert.deepEqual(effects.hooks.map(h => h.hook_event_name), ['SessionStart', 'UserPromptSubmit']);
+    assert.ok(effects.hooks.every(h => h.project_path === project));
+    assert.equal(stop(0).project_path, project);
+  }
+});
+
+test('headless absent project follows cwd then historical core default', async () => {
+  for (const argv of [['--cwd', path.resolve('cwd-project')], []]) {
+    const { effects } = await launchFixture(argv);
+    const expected = argv[1] || path.resolve(__dirname, '../..');
+    assert.equal(effects.contexts[0].projectPath, expected);
+    assert.equal(effects.children[0].args.at(-1), expected);
+  }
+});
+
+test('headless resume preserves continuation without persona or boot reinjection', async () => {
+  const project = path.resolve('resume-project');
+  const { effects } = await launchFixture(['--resume', 'thread-123', '--project-path', project]);
+  assert.equal(effects.children.length, 0);
+  assert.equal(effects.contexts.length, 0);
+  assert.deepEqual(effects.prompts, ['Continue the session.']);
+  assert.ok(effects.spawns[0][1].includes('thread-123'));
+  assert.ok(effects.hooks.every(h => h.project_path === project && h.session_id === 'thread-123'));
+});
+
+test('concurrent headless Stop and child env follow selected project without mutating parent env', async () => {
+  const cwd = path.resolve('unrelated-worktree');
+  const projects = [path.resolve('project-A'), path.resolve('project-B')];
+  const fixtures = await Promise.all(projects.map(project => launchFixture(['--cwd', cwd, '--project-path', project])));
+  await Promise.all(fixtures.map(f => f.close(0)));
+  for (let i = 0; i < fixtures.length; i++) {
+    const { effects, parentEnv } = fixtures[i];
+    assert.equal(effects.stops[0].projectRoot, projects[i]);
+    assert.equal(effects.spawns[0][2].env.KENAZ_CONSOLIDATE_ROOT, projects[i]);
+    assert.equal(effects.spawns[0][2].env.RETAIN_ME, 'yes');
+    assert.equal(effects.spawns[0][2].cwd, cwd);
+    assert.equal(parentEnv.KENAZ_CONSOLIDATE_ROOT, 'unrelated-env');
+    assert.equal(effects.hooks.at(-1).hook_event_name, 'Stop');
+    assert.equal(effects.hooks.at(-1).project_path, projects[i]);
+    assert.deepEqual(effects.exits, [0]);
+  }
+});
+
+test('Stop routing retains resume and default project selection', async () => {
+  for (const argv of [[], ['--cwd', path.resolve('cwd-only')], ['--resume', 'thread-123', '--project-path', path.resolve('resumed-project')]]) {
+    const fixture = await launchFixture(argv);
+    await fixture.close(0);
+    const expected = argv.at(-1) || path.resolve(__dirname, '../..');
+    assert.equal(fixture.effects.stops[0].projectRoot, expected);
+    assert.equal(fixture.effects.spawns[0][2].env.KENAZ_CONSOLIDATE_ROOT, expected);
+  }
+});
+
+test('headless depth follows the shared boot policy: Ansuz elixir, explicit depth and other specialists unchanged', async () => {
+  const depthOf = async argv => {
+    const { effects } = await launchFixture(argv);
+    return effects.children[0].args.find(a => a.startsWith('--depth='));
+  };
+  assert.equal(await depthOf([]), '--depth=elixir');
+  assert.equal(await depthOf(['--depth', 'kernel']), '--depth=kernel');
+  assert.equal(await depthOf(['--specialist', 'Amelia']), '--depth=kernel');
+});