kenaz 0.0.0-stage → 0.3.2

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

@@ -0,0 +1,510 @@
+#!/usr/bin/env node
+/**
+ * Bifröst Launcher — Start an interactive Codex session with full Specialist injection
+ *
+ * Equivalent of opening Claude Code and typing /Ansuz — but for Codex.
+ *
+ * How it works:
+ *   1. Assembles the full Specialist prompt via session.js (same as Claude Code)
+ *   2. Writes it to AGENTS.override.md (Codex reads this with highest priority)
+ *   3. Launches Codex in interactive mode (with MCP + AGENTS.override.md)
+ *   4. On exit, cleans up AGENTS.override.md
+ *
+ * Usage:
+ *   node .formation/bifrost/launch.js --specialist Ansuz
+ *   node .formation/bifrost/launch.js --specialist Ansuz --model o3
+ *   node .formation/bifrost/launch.js                          # defaults to Ansuz
+ *
+ * Prerequisites:
+ *   - codex CLI installed and authenticated
+ *   - Dashboard running (for MCP/Synapse tools)
+ *   (MCP registration is handled automatically by setup-codex.js)
+ */
+
+const { execFileSync, spawn } = require('child_process');
+const http = require('http');
+const path = require('path');
+const fs = require('fs');
+const { renderCodexAntiDrift } = require('./shared/codex-injection');
+const { setup: setupCodex, ensureProjectMcpServers, probeProjectMcpServers } = require('./setup-codex');
+const { fetchBootContext } = require('./shared/boot-context');
+const { resolveBootPolicy, renderBootstrap } = require('./shared/ansuz-boot-policy');
+const appServer = require('./shared/codex-appserver'); // TASK_2167: push-target mode
+
+// task-bridge: required for Bifrost hook dispatch (TASK_1230 — SessionStart/Stop parity)
+// Require path from .formation/bifrost/launch.js → .specialist/tools/task-bridge.js
+const { handleHookEvent } = require(path.resolve(__dirname, '../..', '.specialist/tools/task-bridge.js'));
+
+const ROOT = path.resolve(__dirname, '..', '..');
+const OVERRIDE_PATH = path.join(ROOT, 'AGENTS.override.md');
+const CODEX_CONFIG = path.join(process.env.USERPROFILE || process.env.HOME || '', '.codex', 'config.toml');
+const KENAZ_HTTP_PORT = process.env.KENAZ_HTTP_PORT || '18080';
+
+const args = parseArgs(process.argv.slice(2));
+const SPECIALIST = args.specialist || 'Ansuz';
+const MODEL = args.model || null;
+const BOOT_POLICY = resolveBootPolicy({ specialist: SPECIALIST, depth: args.depth, bootMode: args.bootMode, full: args.full });
+const DEPTH = BOOT_POLICY.depth;
+const PROJECT_PATH = args.project || process.env.KENAZ_PROJECT_PATH || null;
+
+// TASK_1816: menu-entry id → { real CLI model, reasoning_effort } resolution
+// is SHARED with the dispatch path (relay.js exports it, require.main-guarded)
+// so the interactive and dispatch codex entry points can never silently
+// diverge (same twin-divergence class as SUBAGENT_PREFIX, rune_704eeb83).
+// Every codex launch passes an explicit -c model_reasoning_effort — before
+// TASK_1816 nothing did, so sessions silently ran at codex's unset default.
+const { resolveCodexModelSpec } = require('./openai/relay.js');
+const MODEL_SPEC = resolveCodexModelSpec(MODEL);
+
+// ─────────────────────────────────────────
+// Hook Dispatch Ownership (TASK_1230 — SessionStart/Stop parity for interactive launch)
+//
+// launch.js owns SessionStart and Stop for the interactive Codex launcher path.
+// This is distinct from session.js which owns the same events for the headless relay path.
+//
+// Startup integration point:  emitSessionStart() — fires after writeOverride(), before launchCodex()
+// Teardown integration point: emitStop()        — fires in codex.on('close'), before cleanup()
+//
+// Fallback behavior retained:
+//   cleanup() in SIGINT/SIGTERM handlers runs WITHOUT a Stop event because signal handlers
+//   are synchronous and the session may not have fully started. This is intentional — Stop
+//   is only guaranteed when the codex process exits via the close event.
+// ─────────────────────────────────────────
+
+// Module-level timestamp set at SessionStart dispatch; used by normalizeStop().
+let sessionStartedAt = null;
+
+/**
+ * dispatchBifrostHook — launch.js interactive hook dispatcher.
+ * Mirrors the same function in session.js (same contract, same error isolation).
+ */
+function dispatchBifrostHook(eventName, payload) {
+  try {
+    handleHookEvent(payload).catch(err => {
+      process.stderr.write(`[bifrost] ${eventName} hook async error: ${err.message}\n`);
+    });
+    process.stderr.write(`[bifrost] hook fired: ${eventName} | specialist=${SPECIALIST} | mode=interactive\n`);
+  } catch (err) {
+    process.stderr.write(`[bifrost] ${eventName} hook error: ${err.message}\n`);
+  }
+}
+
+/**
+ * normalizeSessionStart — shapes canonical SessionStart payload for interactive launch.
+ */
+function normalizeSessionStart() {
+  return {
+    hook_event_name: 'SessionStart',
+    specialist:      SPECIALIST,
+    adapter:         'codex-interactive',
+    model:           MODEL_SPEC.model || MODEL,
+    reasoning_effort: MODEL_SPEC.reasoning_effort,  // TASK_1816: effort observability
+    cwd:             ROOT,
+    pid:             process.pid,
+    session_id:      null,   // no thread_id in interactive mode until Codex establishes one
+    started_at:      new Date().toISOString(),
+    project_path:    path.resolve(PROJECT_PATH || ROOT),
+  };
+}
+
+/**
+ * normalizeStop — shapes canonical Stop payload for interactive launch close.
+ */
+function normalizeStop(exitCode) {
+  return {
+    hook_event_name: 'Stop',
+    specialist:      SPECIALIST,
+    adapter:         'codex-interactive',
+    exit_code:       exitCode != null ? exitCode : 0,
+    is_error:        (exitCode != null && exitCode !== 0),
+    session_id:      null,
+    total_cost_usd:  0,   // not available from interactive Codex session
+    num_turns:       0,   // not available from interactive Codex session
+    input_tokens:    0,   // not available from interactive Codex session
+    output_tokens:   0,   // not available from interactive Codex session
+    started_at:      sessionStartedAt,
+    ended_at:        new Date().toISOString(),
+    cwd:             ROOT,
+    project_path:    path.resolve(PROJECT_PATH || ROOT),
+  };
+}
+
+// ─────────────────────────────────────────
+// Step 1: Ensure config allows large AGENTS.md
+// ─────────────────────────────────────────
+
+function ensureDocLimit() {
+  if (!fs.existsSync(CODEX_CONFIG)) return;
+  const config = fs.readFileSync(CODEX_CONFIG, 'utf8');
+  if (config.includes('project_doc_max_bytes')) return; // already set
+
+  // Append setting to allow 128KB AGENTS.md (Ansuz prompt is ~60KB)
+  fs.appendFileSync(CODEX_CONFIG, '\nproject_doc_max_bytes = 131072\n');
+  console.log('[bifrost] Set project_doc_max_bytes = 131072 in codex config');
+}
+
+// ─────────────────────────────────────────
+// Step 1b: HTTP probe — verify MCP is reachable before spawning Codex
+// ─────────────────────────────────────────
+
+function probeKenazMcp({ port = KENAZ_HTTP_PORT, timeoutMs = 3000, request = http.request } = {}) {
+  const probeUrl = `http://127.0.0.1:${port}/api/mcp`;
+  return new Promise((resolve) => {
+    let settled = false;
+    let req;
+    const finish = (reachable, reason, toolsCount = 0) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      resolve({ reachable, reason, toolsCount, url: probeUrl });
+    };
+    // Wall-clock bound, including a peer that streams indefinitely.
+    const deadline = setTimeout(() => {
+      finish(false, 'timeout');
+      req?.destroy();
+    }, timeoutMs);
+    const body = JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'tools/list', params: {} });
+    try {
+      req = request({
+        hostname: '127.0.0.1',
+        port: parseInt(port, 10),
+        path: '/api/mcp',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        timeout: timeoutMs,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => {
+          data += chunk;
+          if (data.length > 1024 * 1024) { finish(false, 'response-too-large'); req.destroy(); }
+        });
+        res.on('aborted', () => finish(false, 'response-aborted'));
+        res.on('error', () => finish(false, 'response-error'));
+        res.on('close', () => { if (!res.complete) finish(false, 'response-incomplete'); });
+        res.on('end', () => {
+          if (res.statusCode !== 200) return finish(false, `http-${res.statusCode}`);
+          try {
+            const parsed = JSON.parse(data);
+            const tools = parsed?.tools || parsed?.result?.tools;
+            if (!parsed?.error && Array.isArray(tools) && tools.length > 0) finish(true, 'ok', tools.length);
+            else finish(false, 'tools-list-unavailable');
+          } catch {
+            finish(false, 'invalid-response');
+          }
+        });
+      });
+
+      req.on('timeout', () => {
+        finish(false, 'timeout');
+        req.destroy();
+      });
+
+      req.on('error', (err) => finish(false, err.code || 'request-error'));
+
+      req.write(body);
+      req.end();
+    } catch (err) { finish(false, err.code || 'request-error'); }
+  });
+}
+
+// ─────────────────────────────────────────
+// Step 2: 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);
+  }
+
+  const projectLabel = PROJECT_PATH ? ` [project: ${PROJECT_PATH}]` : '';
+  console.log(`[bifrost] Assembling ${SPECIALIST} prompt (depth=${DEPTH})${projectLabel}...`);
+
+  try {
+    const prompt = execFileSync(process.execPath,
+      [sessionScript, 'prompt', SPECIALIST, '--mode=assembled', `--depth=${DEPTH}`,
+        '--external-boot-context', '--project-path', PROJECT_PATH || ROOT],
+      { cwd: ROOT, encoding: 'utf8', timeout: 30000, maxBuffer: 10 * 1024 * 1024, windowsHide: true }
+    );
+    return prompt.trim();
+  } catch (err) {
+    console.error(`[bifrost] Failed to assemble prompt: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function resolveProjectRoots() {
+  const roots = [];
+  if (PROJECT_PATH) roots.push(path.resolve(PROJECT_PATH));
+  roots.push(ROOT);
+  return [...new Set(roots)];
+}
+
+function runFastBoot() {
+  const script = path.join(ROOT, '.specialist', 'tools', 'ansuz-boot-fast.js');
+  try {
+    const banner = execFileSync(process.execPath, [script, '--project-path', PROJECT_PATH || ROOT,
+      `--mcp-base-url=http://127.0.0.1:${KENAZ_HTTP_PORT}`],
+    { cwd: ROOT, encoding: 'utf8', timeout: 30000, maxBuffer: 10 * 1024 * 1024, windowsHide: true }).trim();
+    // The existing script reports catastrophic failure in stdout with exit 0.
+    if (!banner || banner.includes('[boot error -- see stderr]')) throw new Error('fast boot returned no usable context');
+    return `# Ansuz Fast Boot Context\n${banner}\n\n`;
+  } catch (err) {
+    console.error(`[bifrost] fast boot context unavailable: ${err.message}`);
+    return '# Ansuz Fast Boot Context Unavailable\nFast boot did not complete successfully; do not claim initialization or handoff archival succeeded. Continue local read-only inspection and report this limitation.\n\n';
+  }
+}
+
+function renderMemoryStartupDoc() {
+  for (const base of resolveProjectRoots()) {
+    const filePath = path.join(base, 'memory.md');
+    if (!fs.existsSync(filePath)) continue;
+    const content = fs.readFileSync(filePath, 'utf8').trim();
+    return `# Claude Code Startup Memory (mirrored for Bifröst Codex)\nSource: ${filePath}\n\n\`\`\`md\n${content}\n\`\`\`\n\n`;
+  }
+  return '';
+}
+
+// Codex anti-drift injection now lives in shared/codex-injection.js
+// (extended from a single DDx block to 8 protocols after the 4/9 audit).
+// Both launch.js and session.js use it so headless dispatch is also covered.
+
+// ─────────────────────────────────────────
+// Step 3: Write AGENTS.override.md
+// ─────────────────────────────────────────
+
+function renderOverride(prompt, bootContext, { policy = BOOT_POLICY, projectPath = PROJECT_PATH, memoryStartupDoc = '' } = {}) {
+  const projectInstruction = projectPath
+    ? `You are working on sub-project: ${projectPath}\nAll task-api.js commands must include --project-path="${projectPath}".\nAll MCP tool calls (synapse_*, hippocampus_*, etc.) must include projectPath="${projectPath}".\n\n`
+    : '';
+  const codexDdxInjection = renderCodexAntiDrift();
+
+  // Prepend memory.md mirror + Codex anti-drift protocols (from main) before
+  // the activation banner so Codex sees both the user's auto-memory and the
+  // 8 anti-drift protocols at the top of AGENTS.override.md.
+  const content = `${projectInstruction}${bootContext}${memoryStartupDoc}${codexDdxInjection}You have been activated as ${policy.specialist} via Bifröst.
+
+IMPORTANT — Shell compatibility (you are running under Codex which uses PowerShell on Windows):
+- When calling phase-gate.js exit with --data, do NOT pass JSON inline. PowerShell mangles JSON quotes.
+- Instead: write JSON to a temp file, then use --data-file=path. Example:
+  1. Write: Set-Content -Path _phase_data.json -Value '{"ash_loaded":true,"poem_displayed":true,"session_handoff_loaded":false}'
+  2. Run: node .specialist/tools/phase-gate.js exit --phase=0 --data-file=_phase_data.json
+  3. Cleanup: Remove-Item _phase_data.json
+- This applies to ALL phase-gate.js exit calls, not just Phase 0.
+
+${prompt}
+
+${renderBootstrap({ policy, projectPath, port: KENAZ_HTTP_PORT })}
+`;
+  return content;
+}
+
+function writeOverride(prompt, bootContext) {
+  const content = renderOverride(prompt, bootContext, { memoryStartupDoc: renderMemoryStartupDoc() });
+
+  fs.writeFileSync(OVERRIDE_PATH, content, 'utf8');
+
+  // Write adapter signal file so headless.js knows to route through Bifröst
+  const signalPath = path.join(ROOT, '.formation', '.bifrost-active');
+  fs.writeFileSync(signalPath, JSON.stringify({ adapter: 'openai', specialist: SPECIALIST, pid: process.pid, started: new Date().toISOString() }));
+
+  console.log(`[bifrost] Wrote AGENTS.override.md (${content.length} chars)`);
+}
+
+// ─────────────────────────────────────────
+// Step 4: Launch Codex interactive
+// ─────────────────────────────────────────
+
+let stopPush = () => {};
+
+function killTree(child) {
+  try {
+    if (process.platform === 'win32' && child.pid) execFileSync('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore' }); // own child PID only
+    else child.kill('SIGTERM');
+  } catch { /* already gone */ }
+}
+
+/** TASK_2167: start `codex app-server --listen ws://127.0.0.1:<port>` and wait
+ * (bounded) for the endpoint. Returns { child, wsUrl } or null (and prints one
+ * line) so the caller falls back to the plain TUI. Loopback only. */
+async function startPushServer(env, {
+  spawnFn = spawn, readyTimeoutMs = 15000,
+  pushEnabled = true, hasWebSocket = typeof WebSocket === 'function',
+} = {}) {
+  // Rooms that did not opt in (codex_push off, the default) keep today's plain
+  // TUI: no app-server, no experimental --remote. Without a global WebSocket
+  // (Node < 22) the readiness wait could never succeed, so skip instead of
+  // making every launch wait the full timeout.
+  if (!pushEnabled) return null;
+  if (!hasWebSocket) {
+    console.log('[bifrost] peer push unavailable for this session (Node >= 22 global WebSocket required); using plain TUI + hook pull');
+    return null;
+  }
+  let child = null;
+  try {
+    const port = await appServer.pickFreePort();
+    const wsUrl = appServer.wsUrlFor(port);
+    let dead = false;
+    child = spawnFn('codex', ['app-server', '--listen', wsUrl], { cwd: ROOT, stdio: 'ignore', shell: true, windowsHide: true, env });
+    child.on('error', () => { dead = true; });
+    child.on('exit', () => { dead = true; });
+    const ok = await appServer.waitForWs(wsUrl, { timeoutMs: readyTimeoutMs, isAlive: () => !dead });
+    if (!ok) throw new Error('app-server did not accept connections');
+    console.log(`[bifrost] push target: app-server ${wsUrl} (TUI attached via --remote)`);
+    return { child, wsUrl };
+  } catch (err) {
+    if (child) killTree(child);
+    console.log(`[bifrost] peer push unavailable for this session (${err.message}); using plain TUI + hook pull`);
+    return null;
+  }
+}
+
+async function launchCodex(probe) {
+  // -a never: don't pause for per-tool user approval — Ansuz must run autonomously.
+  // Paired with -s danger-full-access (already sandbox-bypassed); without -a Codex
+  // defaults to on-request and the model keeps stopping to wait for user.
+  const codexArgs = ['-s', 'danger-full-access', '-a', 'never'];
+  // TASK_1816: -m carries the REAL model name (menu-entry ids like
+  // gpt-5.6-sol-high resolve to gpt-5.6-sol); effort is always explicit.
+  // Bare TOML value (no inner quotes) — codex accepts it, and quoting would
+  // break under win32 `shell: true` escaping.
+  if (MODEL_SPEC.model) codexArgs.push('-m', MODEL_SPEC.model);
+  codexArgs.push('-c', `model_reasoning_effort=${MODEL_SPEC.reasoning_effort}`);
+  // Initial prompt: simple trigger — project context is already in AGENTS.override.md
+  codexArgs.push(`/${SPECIALIST}`);
+
+  const projectLabel = PROJECT_PATH ? ` | Project: ${PROJECT_PATH}` : '';
+  console.log(`[bifrost] Launching Codex interactive | Specialist: ${SPECIALIST} | Model: ${MODEL_SPEC.model || 'default'} | Effort: ${MODEL_SPEC.reasoning_effort}${projectLabel}`);
+  if (MODEL && MODEL !== MODEL_SPEC.model) {
+    console.log(`[bifrost] model entry "${MODEL}" resolved → -m ${MODEL_SPEC.model || '(none)'}`);
+  }
+  console.log(`[bifrost] MCP: kenaz-dashboard ${probe.reachable ? 'reachable (tools/list probe)' : `unavailable (${probe.reason}); Ansuz read-only offline mode`}`);
+  console.log(`[bifrost] Press Ctrl+C to exit\n`);
+
+  // TASK_2167: push-target mode. Run a loopback-only app-server and attach the
+  // normal TUI to it (--remote) so codex_wake.rs can turn/steer|turn/start into
+  // this session. Any failure => today's plain TUI, nothing registered.
+  const childEnv = { ...process.env, BIFROST_ADAPTER: 'openai', KENAZ_CONSOLIDATE_ROOT: path.resolve(PROJECT_PATH || ROOT), KENAZ_PEER_PULL: '1' }; // TASK_2299: only the interactive session pulls peer mail
+  const projectRoot = path.resolve(PROJECT_PATH || ROOT);
+  const push = await startPushServer(childEnv, { pushEnabled: appServer.codexPushEnabled(projectRoot) });
+  const tuiArgs = appServer.buildTuiArgs(codexArgs, push && push.wsUrl);
+
+  const codex = spawn('codex', tuiArgs, {
+    cwd: ROOT,
+    stdio: 'inherit',
+    shell: true,
+    windowsHide: false,
+    env: childEnv
+  });
+  let watcher = null;
+  if (push) {
+    watcher = appServer.startThreadWatcher({ projectRoot, wsUrl: push.wsUrl, pid: process.pid });
+    // app-server died: drop the entry; the TUI keeps running and the pull path is unaffected.
+    push.child.on('exit', () => { if (watcher) { watcher.stop(); watcher = null; } });
+  }
+  stopPush = () => { if (watcher) { watcher.stop(); watcher = null; } if (push) killTree(push.child); };
+
+  codex.on('close', (code) => {
+    // ── Stop hook (TASK_1230) ──────────────────────────────────────────────
+    // Fires before cleanup() so the session boundary is observable even if
+    // AGENTS.override.md cleanup fails. Stop is always the last lifecycle event.
+    // Teardown integration point for interactive launch path.
+    dispatchBifrostHook('Stop', normalizeStop(code));
+    // ───────────────────────────────────────────────────────────────────────
+    stopPush();
+    cleanup();
+    process.exit(code || 0);
+  });
+
+  codex.on('error', (err) => {
+    console.error(`[bifrost] Failed to launch codex: ${err.message}`);
+    stopPush();
+    cleanup();
+    process.exit(1);
+  });
+
+  // Cleanup on signals
+  process.on('SIGINT', () => { stopPush(); cleanup(); process.exit(0); });
+  process.on('SIGTERM', () => { stopPush(); cleanup(); process.exit(0); });
+  process.on('exit', () => stopPush());
+}
+
+// ─────────────────────────────────────────
+// Cleanup
+// ─────────────────────────────────────────
+
+function cleanup() {
+  if (fs.existsSync(OVERRIDE_PATH)) {
+    fs.unlinkSync(OVERRIDE_PATH);
+  }
+  const signalPath = path.join(ROOT, '.formation', '.bifrost-active');
+  if (fs.existsSync(signalPath)) {
+    fs.unlinkSync(signalPath);
+  }
+  console.log('\n[bifrost] Cleaned up AGENTS.override.md + .bifrost-active');
+}
+
+// ─────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────
+
+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] === '--model' && argv[i + 1]) result.model = argv[++i];
+    else if (argv[i] === '--depth' && argv[i + 1]) result.depth = argv[++i];
+    else if (argv[i] === '--project' && argv[i + 1]) result.project = argv[++i];
+    else if (argv[i] === '--boot-mode' && argv[i + 1]) result.bootMode = argv[++i];
+    else if (argv[i].startsWith('--boot-mode=')) result.bootMode = argv[i].slice('--boot-mode='.length);
+    else if (argv[i].startsWith('--depth=')) result.depth = argv[i].slice('--depth='.length);
+    else if (argv[i] === '--full') result.full = true;
+  }
+  return result;
+}
+
+// ─────────────────────────────────���───────
+// Main
+// ─────────────────────────────────────────
+
+async function main() {
+  ensureDocLimit();
+  setupCodex({ silent: false });
+  // TASK_1780: register the MCP servers this project declares in
+  // .kenaz/project.yaml (idempotent). Fail-open — a registration problem
+  // must never block an interactive launch.
+  try { ensureProjectMcpServers(PROJECT_PATH || ROOT, { silent: false }); }
+  catch (err) { process.stderr.write(`[bifrost] project MCP registration skipped: ${err.message}\n`); }
+  const probe = await probeKenazMcp();
+  console.log(`[bifrost:probe] reachable=${probe.reachable} url=${probe.url} tools_count=${probe.toolsCount} reason=${probe.reason}`);
+  if (!probe.reachable && !BOOT_POLICY.allowOffline) {
+    throw new Error(`kenaz-dashboard MCP unavailable (${probe.reason}); start Kenaz Dashboard on port ${KENAZ_HTTP_PORT} then retry`);
+  }
+  // TASK_1780: probe declared project servers — WARN-ONLY (unlike the
+  // kenaz-dashboard probe above, an unreachable project server does not
+  // abort: e.g. Unity MCP only exists while the editor is open).
+  await probeProjectMcpServers(PROJECT_PATH || ROOT).catch(() => {});
+  const prompt = assemblePrompt();
+  // TASK_1734: fetch boot cognitive context (preamble + canary + handoff)
+  const bootCtx = BOOT_POLICY.mode === 'fast'
+    ? runFastBoot()
+    : await fetchBootContext({ specialist: SPECIALIST, projectRoot: ROOT, projectPath: PROJECT_PATH || ROOT, includeCanary: false });
+  const offlineNote = probe.reachable ? ''
+    : '# Boot context availability\nInitial Kenaz MCP probe failed; live recall availability is not established. Local fast boot context is not proof of a successful synapse_status check.\n\n';
+  writeOverride(prompt, offlineNote + bootCtx);
+  // ── SessionStart hook (TASK_1230) ─────────────────────────────────────────
+  // Fires after prompt is written (AGENTS.override.md exists) but before Codex
+  // launches. Ordering guarantee: SessionStart precedes first assistant output.
+  const ssPayload = normalizeSessionStart();
+  sessionStartedAt = ssPayload.started_at;
+  dispatchBifrostHook('SessionStart', ssPayload);
+  // ─────────────────────────────────────────────────────────────────────────
+  await launchCodex(probe);
+}
+
+if (require.main === module) {
+  main().catch(err => { console.error(`[bifrost] ${err.message}`); process.exitCode = 1; });
+}
+
+module.exports = { parseArgs, probeKenazMcp, renderOverride, main, startPushServer };