@shanesaravia/hive 0.1.0

package/packages/server/dist/api/ws.js

@@ -0,0 +1,37 @@
+import { buildFleetSnapshot } from "../roster/rosterBuilder.js";
+/**
+ * Single WS endpoint pushing roster + event deltas. The frontend never polls
+ * REST for live state — this is the only steady-state channel.
+ */
+export function registerWs(app, deps) {
+    const { sessionsWatcher, jobsWatcher, events, missions, messages, plans } = deps;
+    const clients = new Set();
+    function broadcastRoster() {
+        const snapshot = buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans);
+        const msg = JSON.stringify({ type: "roster", snapshot });
+        for (const client of clients)
+            client.send(msg);
+    }
+    function broadcastEvent(event) {
+        const msg = JSON.stringify({ type: "event", event });
+        for (const client of clients)
+            client.send(msg);
+    }
+    sessionsWatcher.onChange(broadcastRoster);
+    jobsWatcher.onJobsChange(broadcastRoster);
+    missions.onChange(broadcastRoster);
+    messages.onChange(broadcastRoster);
+    plans.onChange(broadcastRoster);
+    events.onEvent((event) => {
+        broadcastEvent(event);
+        broadcastRoster();
+    });
+    app.get("/ws", { websocket: true }, (socket) => {
+        clients.add(socket);
+        socket.send(JSON.stringify({
+            type: "roster",
+            snapshot: buildFleetSnapshot(sessionsWatcher.getAll(), jobsWatcher.getAll(), events, missions, messages, plans),
+        }));
+        socket.on("close", () => clients.delete(socket));
+    });
+}

package/packages/server/dist/config.js

@@ -0,0 +1,24 @@
+import os from "node:os";
+import path from "node:path";
+const home = os.homedir();
+const port = Number(process.env.HIVE_PORT ?? 4317);
+const hiveDataDir = process.env.HIVE_DATA_DIR ?? path.join(home, ".claude-hive");
+export const config = {
+    claudeDir: path.join(home, ".claude"),
+    sessionsDir: path.join(home, ".claude", "sessions"),
+    jobsDir: path.join(home, ".claude", "jobs"),
+    settingsPath: path.join(home, ".claude", "settings.json"),
+    hiveDataDir,
+    eventsLogPath: path.join(hiveDataDir, "events.jsonl"),
+    hookSpoolPath: path.join(hiveDataDir, "hook-spool.jsonl"),
+    hookRelayPath: path.join(hiveDataDir, "hive-hook-relay.cjs"),
+    threadsPath: path.join(hiveDataDir, "threads.json"),
+    missionsPath: path.join(hiveDataDir, "missions.json"),
+    policiesPath: path.join(hiveDataDir, "policies.json"),
+    codexJobsDir: path.join(hiveDataDir, "codex-jobs"),
+    codexSessionsDir: path.join(hiveDataDir, "codex-sessions"),
+    databasePath: path.join(hiveDataDir, "hive.db"),
+    stalledAfterMs: Number(process.env.HIVE_STALLED_AFTER_MS ?? 10 * 60 * 1000),
+    port,
+    dashboardUrl: process.env.HIVE_DASHBOARD_URL ?? `http://127.0.0.1:${port}`,
+};

package/packages/server/dist/control/codexRuntime.js

@@ -0,0 +1,169 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
+import { config } from "../config.js";
+import { enforceWorkingDirectory } from "../policies/policiesStore.js";
+import { requireWorkingDirectory } from "../paths/pathResolver.js";
+const HIVE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../../..");
+export class CodexRuntime {
+    monitor;
+    init() { fs.mkdirSync(config.codexJobsDir, { recursive: true }); fs.mkdirSync(config.codexSessionsDir, { recursive: true }); this.reconcile(); this.monitor = setInterval(() => this.reconcile(), 1_000); this.monitor.unref(); }
+    async start(options) {
+        const cwd = requireWorkingDirectory(options.cwd);
+        enforceWorkingDirectory(cwd, options.policy);
+        const jobId = `codex-${randomUUID()}`;
+        const directory = path.join(config.codexJobsDir, jobId);
+        fs.mkdirSync(directory, { recursive: true });
+        const timelinePath = path.join(directory, "timeline.jsonl");
+        const stderrPath = path.join(directory, "stderr.log");
+        const output = fs.openSync(timelinePath, "a");
+        const error = fs.openSync(stderrPath, "a");
+        const args = options.resumeSessionId ? ["exec", "resume", "--json", "--skip-git-repo-check"] : ["exec", "--json", "--skip-git-repo-check", "-C", cwd, "-s", "workspace-write"];
+        if (options.model)
+            args.push("-m", options.model);
+        args.push("-c", 'approval_policy="never"');
+        if (!options.policy.networkAccess)
+            args.push("-c", 'web_search="disabled"');
+        if (options.resumeSessionId)
+            args.push(options.resumeSessionId);
+        args.push(this.prompt(options, jobId));
+        const createdAt = new Date().toISOString();
+        const child = spawn("codex", args, { cwd, detached: true, stdio: ["ignore", output, error] });
+        fs.closeSync(output);
+        fs.closeSync(error);
+        await new Promise((resolve, reject) => { child.once("spawn", resolve); child.once("error", reject); });
+        const provisionalSessionId = options.resumeSessionId ?? jobId;
+        this.writeJob(jobId, { state: "working", detail: "Codex turn running", fan: [], children: [], intent: options.task, name: options.name, sessionId: provisionalSessionId, resumeSessionId: options.resumeSessionId, cwd, originCwd: cwd, createdAt, updatedAt: createdAt, backend: "codex", template: options.mode === "orchestrated" ? "hive-orchestrator" : undefined, daemonShort: String(child.pid), cliVersion: "codex" });
+        this.writeSession(child.pid, provisionalSessionId, jobId, cwd, options.name);
+        child.unref();
+        let effectiveSessionId = provisionalSessionId;
+        child.once("close", (code) => this.complete(jobId, child.pid, effectiveSessionId, code ?? 1));
+        const sessionId = await this.waitForThread(timelinePath, provisionalSessionId);
+        effectiveSessionId = sessionId;
+        if (sessionId !== provisionalSessionId) {
+            const job = this.readJob(jobId);
+            job.sessionId = sessionId;
+            this.writeJob(jobId, job);
+            this.writeSession(child.pid, sessionId, jobId, cwd, options.name);
+        }
+        return { pid: child.pid, jobId, sessionId, cwd };
+    }
+    async stop(jobId) {
+        const job = this.readJob(jobId);
+        const pid = Number(job?.daemonShort);
+        if (!job || !Number.isInteger(pid))
+            throw new Error("Codex job not found");
+        process.kill(pid, "SIGTERM");
+        job.state = "stopped";
+        job.detail = "Stopped by user; conversation can be resumed";
+        job.updatedAt = new Date().toISOString();
+        this.writeJob(jobId, job);
+        this.removeSession(pid);
+    }
+    prompt(options, jobId) {
+        let manager = "";
+        if (options.mode === "orchestrated") {
+            try {
+                const source = fs.readFileSync(path.join(HIVE_ROOT, "templates", "agents", "hive-orchestrator.md"), "utf8");
+                const emit = `npx tsx '${path.join(HIVE_ROOT, "bin", "hive-emit.ts").replaceAll("'", "'\\''")}' --sessionId '${jobId}' --jobId '${jobId}'`;
+                manager = `${source.replace(/^---[\s\S]*?---\s*/, "").replaceAll("{{HIVE_EMIT_CMD}}", emit)}\n\nCodex adaptation: delegate through Codex collaboration/subagent tools available in this session. The workspace-write sandbox is the structural editing boundary; follow the mission action policy below.\n\n`;
+            }
+            catch {
+                manager = "You are the manager for a Hive mission. Delegate independent work to subagents when useful, keep a structured plan current, and synthesize their evidence.\n\n";
+            }
+        }
+        return `${manager}${options.task}\n\nHive policy: ${JSON.stringify(options.policy)}. Work only inside the selected repository and workspace sandbox. Do not commit, push, open PRs, release, publish, use network access, or perform destructive actions when the corresponding policy value is false. If access or budget expansion is needed, stop and clearly ask the user for approval.`;
+    }
+    complete(jobId, pid, sessionId, code) {
+        const job = this.readJob(jobId);
+        if (!job || job.state !== "working")
+            return;
+        const events = readJsonLines(path.join(config.codexJobsDir, jobId, "timeline.jsonl"));
+        const message = events.filter((event) => event.type === "item.completed" && object(event.item)?.type === "agent_message").map((event) => String(object(event.item)?.text ?? "")).filter(Boolean).at(-1);
+        const usage = object([...events].reverse().find((event) => event.type === "turn.completed")?.usage);
+        job.state = code === 0 ? "done" : "error";
+        job.detail = code === 0 ? "Codex turn completed" : `Codex exited with code ${code}`;
+        job.output = message;
+        job.tokens = Number(usage?.input_tokens ?? 0) + Number(usage?.output_tokens ?? 0);
+        job.sessionId = sessionId;
+        job.updatedAt = new Date().toISOString();
+        this.writeJob(jobId, job);
+        this.removeSession(pid);
+    }
+    async waitForThread(file, fallback) { const deadline = Date.now() + 8_000; while (Date.now() < deadline) {
+        const started = readJsonLines(file).find((event) => event.type === "thread.started");
+        if (started?.thread_id)
+            return String(started.thread_id);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    } return fallback; }
+    reconcile() {
+        for (const jobId of safeEntries(config.codexJobsDir)) {
+            const job = this.readJob(jobId);
+            if (!job || job.state !== "working")
+                continue;
+            const pid = Number(job.daemonShort);
+            const completed = readJsonLines(path.join(config.codexJobsDir, jobId, "timeline.jsonl")).some((event) => event.type === "turn.completed");
+            if (completed)
+                this.complete(jobId, pid, job.sessionId ?? job.resumeSessionId ?? jobId, 0);
+            else {
+                let alive = false;
+                try {
+                    process.kill(pid, 0);
+                    alive = true;
+                }
+                catch { }
+                if (!alive) {
+                    job.state = "error";
+                    job.detail = "Codex turn was interrupted while Hive was offline";
+                    job.updatedAt = new Date().toISOString();
+                    this.writeJob(jobId, job);
+                }
+            }
+        }
+        for (const entry of safeEntries(config.codexSessionsDir)) {
+            try {
+                const session = JSON.parse(fs.readFileSync(path.join(config.codexSessionsDir, entry), "utf8"));
+                process.kill(session.pid, 0);
+            }
+            catch {
+                try {
+                    fs.unlinkSync(path.join(config.codexSessionsDir, entry));
+                }
+                catch { }
+            }
+        }
+    }
+    readJob(jobId) { try {
+        return JSON.parse(fs.readFileSync(path.join(config.codexJobsDir, jobId, "state.json"), "utf8"));
+    }
+    catch {
+        return undefined;
+    } }
+    writeJob(jobId, job) { atomicWrite(path.join(config.codexJobsDir, jobId, "state.json"), job); }
+    writeSession(pid, sessionId, jobId, cwd, name) { atomicWrite(path.join(config.codexSessionsDir, `${pid}.json`), { pid, sessionId, cwd, startedAt: Date.now(), updatedAt: Date.now(), status: "busy", jobId, name, agent: "hive-orchestrator", entrypoint: "codex" }); }
+    removeSession(pid) { try {
+        fs.unlinkSync(path.join(config.codexSessionsDir, `${pid}.json`));
+    }
+    catch { } }
+}
+function atomicWrite(file, value) { const temporary = `${file}.tmp`; fs.writeFileSync(temporary, JSON.stringify(value, null, 2)); fs.renameSync(temporary, file); }
+function safeEntries(directory) { try {
+    return fs.readdirSync(directory);
+}
+catch {
+    return [];
+} }
+function object(value) { return value && typeof value === "object" ? value : undefined; }
+function readJsonLines(file) { try {
+    return fs.readFileSync(file, "utf8").split("\n").filter(Boolean).flatMap((line) => { try {
+        return [JSON.parse(line)];
+    }
+    catch {
+        return [];
+    } });
+}
+catch {
+    return [];
+} }

package/packages/server/dist/control/killer.js

@@ -0,0 +1,25 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+/**
+ * Stops a background job through Claude's lifecycle command. Unlike killing
+ * its current process, this keeps the conversation resumable and tells the
+ * daemon not to bring the job back.
+ */
+export async function stopSession(jobId) {
+    await execFileAsync("claude", buildStopArgs(jobId));
+}
+export function buildStopArgs(jobId) { return ["stop", jobId]; }
+/** Hard-stop escape hatch for a process that does not respond to `claude stop`. */
+export function forceStopSession(pid) {
+    process.kill(pid, "SIGKILL");
+}
+export function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/packages/server/dist/control/launcher.js

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { config } from "../config.js";
+import { requireWorkingDirectory } from "../paths/pathResolver.js";
+import { disallowedTools } from "../policies/policiesStore.js";
+const ORCHESTRATOR_AGENT = "hive-orchestrator";
+// "Orchestrator never edits code" is enforced by disallowedTools in the
+// hive-orchestrator agent frontmatter, NOT by session-level --disallowedTools:
+// session-level restrictions cascade to worker subagents, which forces workers
+// to assemble files through dozens of Bash printf calls instead of Write.
+// Session-level flags remain reserved for mission-policy boundaries that
+// SHOULD bind workers too (pushes, releases, destructive commands).
+/**
+ * Shells out to the `claude` CLI to launch a new orchestrator as a background
+ * job. Hive does not implement its own spawning/worktree logic — it wraps the
+ * CLI's native --bg/--worktree/--agent primitives.
+ */
+export async function startOrchestrator(opts) {
+    const args = buildLaunchArgs(opts);
+    const before = new Set(listSessionFiles());
+    const cwd = requireWorkingDirectory(opts.cwd);
+    const child = spawn("claude", args, { cwd, detached: true, stdio: "ignore" });
+    child.unref();
+    // Worktree launches must copy/check out the repo before the session
+    // registers, which can take well over 8s on large repositories.
+    const session = await waitForNewSession(before, opts.worktree ? 30000 : 8000);
+    if (!session.jobId) {
+        throw new Error("Orchestrator session started without a background job ID");
+    }
+    return {
+        pid: session.pid,
+        jobId: session.jobId,
+        sessionId: session.sessionId,
+        cwd: session.cwd,
+        sessionFile: path.join(config.sessionsDir, `${session.pid}.json`),
+    };
+}
+export function generateWorktreeName(missionName) {
+    const slug = (missionName ?? "")
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+    const suffix = Math.random().toString(36).slice(2, 8);
+    return slug ? `hive-${slug}-${suffix}` : `hive-${suffix}`;
+}
+export function buildLaunchArgs(opts) {
+    const args = [
+        "--bg",
+        // Background sessions have no TTY to answer permission prompts — "auto"
+        // (the mode Claude Code's own background jobs use) lets it proceed
+        // without stalling. disallowedTools remains the actual safety boundary.
+    ];
+    // Variadic --add-dir must come before the trailing task positional, with a
+    // flag after it, or it would swallow the task as another directory.
+    if (opts.addDirs?.length)
+        args.push("--add-dir", ...opts.addDirs);
+    const denied = opts.policy ? disallowedTools(opts.policy) : [];
+    if ((opts.mode ?? "orchestrated") === "orchestrated") {
+        args.push("--agent", ORCHESTRATOR_AGENT);
+    }
+    if (denied.length)
+        args.push("--disallowedTools", [...new Set(denied)].join(","));
+    if (opts.policy?.allowedTools.length)
+        args.push("--allowedTools", opts.policy.allowedTools.join(","));
+    args.push("--permission-mode", "auto");
+    if (opts.worktree) {
+        // Always pass an explicit name: the CLI's --worktree greedily consumes the
+        // next non-flag argument, so a bare --worktree would swallow the task
+        // prompt as the worktree name (and fail its 64-char/charset validation).
+        args.push("--worktree", typeof opts.worktree === "string" ? opts.worktree : generateWorktreeName(opts.name));
+    }
+    if (opts.name)
+        args.push("--name", opts.name);
+    if (opts.model)
+        args.push("--model", opts.model);
+    args.push(opts.task);
+    return args;
+}
+function listSessionFiles() {
+    try {
+        return fs
+            .readdirSync(config.sessionsDir)
+            .filter((f) => f.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * `claude --bg` detaches immediately, so the only reliable signal that the
+ * new session is up is its sessions/<pid>.json file appearing. Poll the
+ * filesystem briefly (startup confirmation only, not steady-state polling).
+ */
+async function waitForNewSession(before, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const now = listSessionFiles();
+        const added = now.filter((f) => !before.has(f));
+        for (const file of added) {
+            try {
+                const session = JSON.parse(fs.readFileSync(path.join(config.sessionsDir, file), "utf8"));
+                if (Number.isFinite(session.pid) && session.sessionId)
+                    return session;
+            }
+            catch {
+                // The daemon may still be writing the newly discovered file.
+            }
+        }
+        await new Promise((r) => setTimeout(r, 250));
+    }
+    throw new Error("Timed out waiting for orchestrator session to start");
+}

package/packages/server/dist/control/messaging.js

@@ -0,0 +1,75 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { config } from "../config.js";
+import { disallowedTools } from "../policies/policiesStore.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Sends a follow-up message into a running session. The per-session Unix
+ * socket (messagingSocketPath) is an internal/undocumented protocol — rather
+ * than reverse-engineer it against live sessions, this uses the CLI's own
+ * public `--resume` flag as a background turn. `--bg` accepts the message as
+ * the positional prompt; it cannot be combined with print mode (`-p`).
+ * Slower than direct IPC but safe and stable across CLI versions.
+ */
+export async function sendMessage(sessionId, text, policy, addDirs) {
+    const before = new Set(listJobIds());
+    await execFileAsync("claude", buildResumeArgs(sessionId, text, policy, addDirs));
+    return waitForNewJob(before);
+}
+export function buildResumeArgs(sessionId, text, policy, addDirs) {
+    // The prompt positional must precede --resume/--bg: trailing positionals are
+    // silently dropped on resumed background turns (the session starts idle,
+    // "send a prompt to start", and never replies).
+    // Resumes inherit the session's permission mode today, but pin auto
+    // explicitly so a CLI change can never drop follow-up turns into a
+    // prompting mode no background session can answer.
+    const args = [text, "--resume", sessionId, "--bg", "--permission-mode", "auto"];
+    const denied = policy ? disallowedTools(policy) : [];
+    if (denied.length)
+        args.push("--disallowedTools", denied.join(","));
+    if (policy?.allowedTools.length)
+        args.push("--allowedTools", policy.allowedTools.join(","));
+    // Variadic --add-dir goes last: with the prompt already first, there is no
+    // trailing positional for it to swallow.
+    if (addDirs?.length)
+        args.push("--add-dir", ...addDirs);
+    return args;
+}
+function listJobIds() {
+    try {
+        return fs
+            .readdirSync(config.jobsDir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function waitForNewJob(before) {
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+        const added = listJobIds().filter((jobId) => !before.has(jobId));
+        if (added.length) {
+            const jobId = added.sort((a, b) => {
+                const aPath = path.join(config.jobsDir, a);
+                const bPath = path.join(config.jobsDir, b);
+                return fs.statSync(bPath).mtimeMs - fs.statSync(aPath).mtimeMs;
+            })[0];
+            try {
+                const state = JSON.parse(fs.readFileSync(path.join(config.jobsDir, jobId, "state.json"), "utf8"));
+                return {
+                    jobId,
+                    sessionId: state.sessionId ?? state.resumeSessionId,
+                };
+            }
+            catch {
+                return { jobId };
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error("Claude resumed the session but no new job was discovered");
+}

package/packages/server/dist/control/nativeCommands.js

@@ -0,0 +1,29 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { NATIVE_COMMANDS } from "@hive/shared";
+const execFileAsync = promisify(execFile);
+/** Bare "/usage"-style input matching a supported native CLI command. */
+export function matchNativeCommand(text) {
+    const match = text.trim().match(/^\/([a-z-]+)$/);
+    return match ? NATIVE_COMMANDS.find((command) => command.name === match[1]) : undefined;
+}
+/**
+ * Runs a native command headlessly. Sending these into a background session
+ * as a prompt hangs on an interactive dialog, so they run as a one-off
+ * `claude -p` instead. Session-scoped commands resume a FORK of the mission
+ * session so the report reflects it without appending to its history.
+ */
+export async function runNativeCommand(command, opts) {
+    const args = ["-p", `/${command.name}`];
+    if (command.scope === "session") {
+        if (!opts.sessionId)
+            throw new Error("no live session to inspect yet");
+        args.push("--resume", opts.sessionId, "--fork-session");
+    }
+    const { stdout } = await execFileAsync("claude", args, {
+        cwd: opts.cwd,
+        timeout: 180_000,
+        maxBuffer: 4 * 1024 * 1024,
+    });
+    return stdout.trim() || `(/${command.name} returned no output)`;
+}

package/packages/server/dist/control/permissionPark.js

@@ -0,0 +1,23 @@
+/**
+ * Helpers for answering a session parked at a permission prompt. Background
+ * sessions have no TTY and the PermissionRequest hook does not fire for
+ * auto-mode prompts, so approval works by stopping the parked turn and
+ * resuming the conversation with the verdict — granting the asked tool via
+ * allowedTools so the retry does not park again.
+ */
+/** Parses the daemon's park ask ("approve Bash: glab mr view …") into tool + detail. */
+export function parsePermissionAsk(needs) {
+    const match = needs.replace(/^approve\s+/i, "").match(/^([A-Za-z][\w-]*)\s*:?\s*([\s\S]*)$/);
+    return match ? { tool: match[1], detail: match[2].trim() } : undefined;
+}
+/** allowedTools grant that pre-approves the asked action on the resumed turn. */
+export function permissionGrant(needs) {
+    const ask = parsePermissionAsk(needs);
+    if (!ask)
+        return undefined;
+    if (ask.tool === "Bash" && ask.detail) {
+        const prefix = ask.detail.split(/\s+/).slice(0, 3).join(" ");
+        return `Bash(${prefix}:*)`;
+    }
+    return ask.tool;
+}

package/packages/server/dist/control/providerModels.js

@@ -0,0 +1,53 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function detectProviderModels() { return [detectClaudeModels(), detectCodexModels()]; }
+export function parseCodexModels(raw) {
+    const parsed = JSON.parse(raw);
+    return (parsed.models ?? []).filter((model) => model.visibility !== "hide" && typeof model.slug === "string").map((model) => ({ id: String(model.slug), label: typeof model.display_name === "string" ? model.display_name : String(model.slug), ...(typeof model.description === "string" ? { description: model.description } : {}) }));
+}
+export function parseClaudeModels(_help) {
+    return [
+        { id: "sonnet", label: "Sonnet 5", description: "Efficient for routine tasks" },
+        { id: "fable", label: "Fable 5", description: "Most capable for the hardest and longest-running tasks; may require usage credits" },
+        { id: "opus", label: "Opus 5", description: "Best for everyday complex tasks; higher usage" },
+        { id: "haiku", label: "Haiku 4.5", description: "Fastest for quick answers" },
+    ];
+}
+function detectCodexModels() {
+    try {
+        const raw = execFileSync("codex", ["debug", "models"], { encoding: "utf8", timeout: 10_000, stdio: ["ignore", "pipe", "ignore"] });
+        const models = parseCodexModels(raw);
+        const configured = configuredModel(path.join(os.homedir(), ".codex", "config.toml"));
+        return { provider: "codex", available: true, models, defaultModel: models.find((model) => model.id === configured) ?? models[0], detection: "cli-catalog" };
+    }
+    catch (err) {
+        return { provider: "codex", available: false, models: [], detection: "unavailable", error: message(err) };
+    }
+}
+function detectClaudeModels() {
+    try {
+        const help = execFileSync("claude", ["--help"], { encoding: "utf8", timeout: 5_000, stdio: ["ignore", "pipe", "ignore"] });
+        const models = parseClaudeModels(help);
+        const configured = configuredClaudeModel();
+        return { provider: "claude", available: true, models, defaultModel: models.find((model) => configured?.includes(model.id)) ?? models.find((model) => model.id === "sonnet"), detection: "cli-advertised" };
+    }
+    catch (err) {
+        return { provider: "claude", available: false, models: [], detection: "unavailable", error: message(err) };
+    }
+}
+function message(error) { return error instanceof Error ? error.message : String(error); }
+function configuredModel(file) { try {
+    return fs.readFileSync(file, "utf8").match(/^model\s*=\s*["']([^"']+)["']/m)?.[1];
+}
+catch {
+    return undefined;
+} }
+function configuredClaudeModel() { try {
+    const settings = JSON.parse(fs.readFileSync(path.join(os.homedir(), ".claude", "settings.json"), "utf8"));
+    return typeof settings.model === "string" ? settings.model : undefined;
+}
+catch {
+    return undefined;
+} }

package/packages/server/dist/events/eventsStore.js

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import { config } from "../config.js";
+const RING_SIZE = 200;
+/**
+ * In-memory ring buffer per session for fast reads, backed by a durable
+ * append-only JSONL log on disk so history survives server restarts.
+ */
+export class EventsStore {
+    dataDir;
+    logPath;
+    bySession = new Map();
+    listeners = new Set();
+    constructor(dataDir = config.hiveDataDir, logPath = config.eventsLogPath) {
+        this.dataDir = dataDir;
+        this.logPath = logPath;
+    }
+    init() {
+        fs.mkdirSync(this.dataDir, { recursive: true });
+        if (!fs.existsSync(this.logPath)) {
+            fs.writeFileSync(this.logPath, "");
+            return;
+        }
+        const lines = fs.readFileSync(this.logPath, "utf8").split("\n").filter(Boolean);
+        for (const line of lines) {
+            try {
+                const event = JSON.parse(line);
+                if (!event.sessionId || !Number.isFinite(event.ts))
+                    continue;
+                const list = this.bySession.get(event.sessionId) ?? [];
+                list.push(event);
+                if (list.length > RING_SIZE)
+                    list.shift();
+                this.bySession.set(event.sessionId, list);
+            }
+            catch { /* ignore a partially written or invalid historical line */ }
+        }
+    }
+    add(event) {
+        const list = this.bySession.get(event.sessionId) ?? [];
+        list.push(event);
+        if (list.length > RING_SIZE)
+            list.shift();
+        this.bySession.set(event.sessionId, list);
+        fs.appendFileSync(this.logPath, JSON.stringify(event) + "\n");
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    recentFor(sessionId, limit = 50) {
+        const list = this.bySession.get(sessionId) ?? [];
+        return list.slice(-limit);
+    }
+    onEvent(listener) {
+        this.listeners.add(listener);
+    }
+}