@shanesaravia/hive 0.2.1 → 0.4.0

package/packages/server/dist/skills/skillDiscovery.js

@@ -50,17 +50,41 @@ function collectPluginSkills(root) {
     }
     return output;
 }
+/**
+ * A mission's recorded repository can be a directory that no longer exists —
+ * reaching a terminal state reclaims its worktree. The project half of
+ * discovery is unavailable then, but the user's own skills are not, so this
+ * degrades to them rather than failing outright. Failing threw out ten usable
+ * skills over a missing project directory, and, because `sendToMission`
+ * discovers skills before it falls back to a live repository, made messaging
+ * such a mission impossible.
+ */
+function projectSkills(cwd, provider) {
+    let project;
+    try {
+        project = requireWorkingDirectory(cwd);
+    }
+    catch {
+        return [];
+    }
+    return provider === "codex"
+        ? collect(path.join(project, ".codex", "skills"), "project")
+        : [
+            ...collect(path.join(project, ".claude", "skills"), "project"),
+            ...collect(path.join(project, ".claude", "commands"), "project"),
+        ];
+}
 export function discoverSkills(cwd, provider = "claude") {
-    const project = requireWorkingDirectory(cwd);
     const claudeConfig = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude");
     const codexHome = process.env.CODEX_HOME || path.join(os.homedir(), ".codex");
+    // Project entries lead, so the dedup below keeps them over a user skill of
+    // the same name.
     const all = provider === "codex" ? [
-        ...collect(path.join(project, ".codex", "skills"), "project"),
+        ...projectSkills(cwd, provider),
         ...collect(path.join(codexHome, "skills"), "user"),
         ...collectPluginSkills(path.join(codexHome, "plugins", "cache")),
     ] : [
-        ...collect(path.join(project, ".claude", "skills"), "project"),
-        ...collect(path.join(project, ".claude", "commands"), "project"),
+        ...projectSkills(cwd, provider),
         ...collect(path.join(claudeConfig, "skills"), "user"),
         ...collect(path.join(claudeConfig, "commands"), "user"),
     ];

package/packages/server/dist/terminals/claudeStreamClient.js

@@ -0,0 +1,90 @@
+import { spawn } from "node:child_process";
+import { Duplex } from "node:stream";
+export function claudeStreamArguments(options) {
+    const args = ["-p", "--input-format", "stream-json", "--output-format", "stream-json", "--verbose"];
+    if (options.resumeSessionId)
+        args.push("--resume", options.resumeSessionId);
+    if (options.model)
+        args.push("--model", options.model);
+    return args;
+}
+/** Reproducible lifecycle spike; production Claude --bg remains follow-up only. */
+export class ClaudeStreamClient {
+    stream;
+    interruptProcess;
+    terminateProcess;
+    buffer = "";
+    closed = false;
+    listeners = new Set();
+    constructor(stream, interruptProcess = () => undefined, terminateProcess = () => undefined) {
+        this.stream = stream;
+        this.interruptProcess = interruptProcess;
+        this.terminateProcess = terminateProcess;
+        stream.setEncoding("utf8");
+        stream.on("data", (chunk) => this.consume(chunk));
+        stream.on("close", () => this.finish());
+        stream.on("error", (error) => this.emit({ type: "hive/error", message: error.message }));
+    }
+    static spawn(options, command = "claude") {
+        const child = spawn(command, claudeStreamArguments(options), { cwd: options.cwd, stdio: ["pipe", "pipe", "pipe"] });
+        child.stderr.resume();
+        return new ClaudeStreamClient(new ChildDuplex(child), () => { child.kill("SIGINT"); }, () => { child.kill("SIGTERM"); });
+    }
+    send(text, sessionId) {
+        if (this.closed)
+            throw new Error("Claude stream client is closed");
+        const message = { type: "user", message: { role: "user", content: text } };
+        if (sessionId)
+            message.session_id = sessionId;
+        this.stream.write(`${JSON.stringify(message)}\n`);
+    }
+    onEvent(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+    interrupt() { if (!this.closed)
+        this.interruptProcess(); }
+    endInput() { if (!this.closed)
+        this.stream.end(); }
+    close() { if (!this.closed) {
+        this.closed = true;
+        this.stream.end();
+        this.terminateProcess();
+    } }
+    consume(chunk) {
+        this.buffer += chunk;
+        let newline;
+        while ((newline = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event && typeof event.type === "string")
+                    this.emit(event);
+            }
+            catch {
+                this.emit({ type: "hive/invalid-json", line });
+            }
+        }
+    }
+    finish() { if (!this.closed) {
+        this.closed = true;
+        this.emit({ type: "hive/connection/closed" });
+    } }
+    emit(event) { for (const listener of this.listeners)
+        listener(event); }
+}
+class ChildDuplex extends Duplex {
+    child;
+    constructor(child) {
+        super();
+        this.child = child;
+        child.stdout.on("data", (chunk) => this.push(chunk));
+        child.stdout.on("end", () => this.push(null));
+        child.stdout.on("error", (error) => this.destroy(error));
+        child.stdin.on("error", (error) => this.destroy(error));
+        child.once("exit", () => this.push(null));
+    }
+    _read() { }
+    _write(chunk, encoding, callback) { this.child.stdin.write(chunk, encoding, callback); }
+    _final(callback) { this.child.stdin.end(callback); }
+}

package/packages/server/dist/terminals/codexAppServerClient.js

@@ -0,0 +1,195 @@
+import { spawn } from "node:child_process";
+import { Duplex } from "node:stream";
+/** Minimal JSON-RPC client for the versioned Codex app-server boundary. */
+export class CodexAppServerClient {
+    stream;
+    child;
+    nextId = 1;
+    buffer = "";
+    closed = false;
+    pending = new Map();
+    listeners = new Set();
+    constructor(stream, child) {
+        this.stream = stream;
+        this.child = child;
+        stream.setEncoding("utf8");
+        stream.on("data", (chunk) => this.consume(chunk));
+        stream.on("error", (error) => this.failAll(error));
+        stream.on("close", () => {
+            if (!this.closed) {
+                this.closed = true;
+                this.emit({ method: "hive/connection/closed" });
+            }
+            this.failAll(new Error("Codex app-server connection closed"));
+        });
+    }
+    static spawn(command = "codex") {
+        const child = spawn(command, ["app-server", "--stdio"], { stdio: ["pipe", "pipe", "pipe"] });
+        // The protocol lives on stdout. Drain stderr so warnings cannot block it.
+        child.stderr.resume();
+        return new CodexAppServerClient(new ChildDuplex(child), child);
+    }
+    /** Restart the stdio server and rejoin a persisted thread by id. */
+    static async reconnectStdio(threadId, options = {}, command = "codex") {
+        const client = CodexAppServerClient.spawn(command);
+        try {
+            await client.initialize();
+            await client.resumeThread(threadId, options);
+            return client;
+        }
+        catch (error) {
+            client.close();
+            throw error;
+        }
+    }
+    static connectUnix(socketPath) {
+        // The daemon endpoint is a control socket, not raw JSONL. Codex owns its
+        // framing contract and exposes `proxy` as the supported stdio bridge.
+        const child = spawn("codex", ["app-server", "proxy", "--sock", socketPath], { stdio: ["pipe", "pipe", "pipe"] });
+        child.stderr.resume();
+        return Promise.resolve(new CodexAppServerClient(new ChildDuplex(child), child));
+    }
+    /** Rejoin a durable daemon connection and resubscribe to an existing thread. */
+    static async reconnectUnix(socketPath, threadId, options = {}) {
+        const client = await CodexAppServerClient.connectUnix(socketPath);
+        try {
+            await client.initialize();
+            await client.resumeThread(threadId, options);
+            return client;
+        }
+        catch (error) {
+            client.close();
+            throw error;
+        }
+    }
+    async initialize() {
+        const result = await this.request("initialize", { clientInfo: { name: "hive", title: "Hive", version: "0.3.0" }, capabilities: { experimentalApi: true, requestAttestation: false } });
+        this.notify("initialized");
+        return result;
+    }
+    async startThread(options) {
+        const result = await this.request("thread/start", { cwd: options.cwd, model: options.model, approvalPolicy: options.approvalPolicy ?? "never", sandbox: options.sandbox ?? "workspace-write", threadSource: "appServer" });
+        return { threadId: nestedId(result, "thread") };
+    }
+    async resumeThread(threadId, options = {}) {
+        const result = await this.request("thread/resume", { threadId, cwd: options.cwd, model: options.model, approvalPolicy: options.approvalPolicy, sandbox: options.sandbox, excludeTurns: true });
+        return { threadId: nestedId(result, "thread") };
+    }
+    async startTurn(threadId, text) {
+        const result = await this.request("turn/start", { threadId, input: [{ type: "text", text, text_elements: [] }] });
+        return { turnId: nestedId(result, "turn") };
+    }
+    async interruptTurn(threadId, turnId) {
+        await this.request("turn/interrupt", { threadId, turnId });
+    }
+    async deleteThread(threadId) { await this.request("thread/delete", { threadId }); }
+    onNotification(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit(notification) {
+        for (const listener of this.listeners)
+            listener(notification);
+    }
+    waitForNotification(predicate, timeoutMs = 30_000) {
+        return new Promise((resolve, reject) => {
+            const unsubscribe = this.onNotification((notification) => {
+                if (!predicate(notification))
+                    return;
+                clearTimeout(timer);
+                unsubscribe();
+                resolve(notification);
+            });
+            const timer = setTimeout(() => { unsubscribe(); reject(new Error("Timed out waiting for a Codex app-server notification")); }, timeoutMs);
+            timer.unref?.();
+        });
+    }
+    async request(method, params, timeoutMs = 10_000) {
+        if (this.closed)
+            throw new Error("Codex app-server client is closed");
+        const id = this.nextId++;
+        const response = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Codex app-server ${method} timed out`)); }, timeoutMs);
+            timer.unref?.();
+            this.pending.set(id, { resolve, reject, timer });
+        });
+        this.write({ method, id, params });
+        const result = await response;
+        return object(result);
+    }
+    notify(method, params) { this.write(params === undefined ? { method } : { method, params }); }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.stream.end();
+        if (this.child && !this.child.killed)
+            this.child.kill("SIGTERM");
+        this.failAll(new Error("Codex app-server client closed"));
+    }
+    write(message) { this.stream.write(`${JSON.stringify(message)}\n`); }
+    consume(chunk) {
+        this.buffer += chunk;
+        let newline;
+        while ((newline = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, newline).trim();
+            this.buffer = this.buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                message = object(JSON.parse(line));
+            }
+            catch {
+                continue;
+            }
+            if (typeof message.id === "number") {
+                const pending = this.pending.get(message.id);
+                if (!pending)
+                    continue;
+                this.pending.delete(message.id);
+                clearTimeout(pending.timer);
+                if (message.error)
+                    pending.reject(new Error(rpcError(message.error)));
+                else
+                    pending.resolve(message.result);
+            }
+            else if (typeof message.method === "string") {
+                const notification = { method: message.method, params: isObject(message.params) ? message.params : undefined };
+                this.listeners.forEach((listener) => listener(notification));
+            }
+        }
+    }
+    failAll(error) { for (const request of this.pending.values()) {
+        clearTimeout(request.timer);
+        request.reject(error);
+    } this.pending.clear(); }
+}
+/** Bridges a child's separate stdin/stdout into the Duplex shape used by sockets and tests. */
+class ChildDuplex extends Duplex {
+    input;
+    constructor(child) {
+        super();
+        this.input = child.stdin;
+        child.stdout.on("data", (chunk) => this.push(chunk));
+        child.stdout.on("end", () => this.push(null));
+        child.stdout.on("error", (error) => this.destroy(error));
+        child.stdin.on("error", (error) => this.destroy(error));
+        child.once("exit", () => this.push(null));
+    }
+    _read() { }
+    _write(chunk, encoding, callback) {
+        this.input.write(chunk, encoding, callback);
+    }
+    _final(callback) { this.input.end(callback); }
+}
+function nestedId(result, key) {
+    const id = object(result[key]).id;
+    if (typeof id !== "string" || !id)
+        throw new Error(`Codex app-server ${key} response omitted its id`);
+    return id;
+}
+function isObject(value) { return Boolean(value) && typeof value === "object" && !Array.isArray(value); }
+function object(value) { if (!isObject(value))
+    throw new Error("Codex app-server returned an invalid response"); return value; }
+function rpcError(value) { const error = isObject(value) ? value : {}; return typeof error.message === "string" ? error.message : "Codex app-server request failed"; }

package/packages/server/dist/terminals/providerDetection.js

@@ -0,0 +1,27 @@
+import { execFileSync } from "node:child_process";
+const systemRun = (file, args) => execFileSync(file, args, { encoding: "utf8", timeout: 5_000, stdio: ["ignore", "pipe", "pipe"] });
+function versionOf(output) {
+    return output.match(/\d+\.\d+\.\d+(?:[-+][\w.-]+)?/)?.[0];
+}
+export function detectProviderTerminal(provider, run = systemRun) {
+    try {
+        const versionOutput = run(provider, ["--version"]);
+        const version = versionOf(versionOutput);
+        const help = provider === "codex" ? run("codex", ["app-server", "--help"]) : run("claude", ["--help"]);
+        if (provider === "codex") {
+            const supported = help.includes("--listen") && help.includes("stdio://") && help.includes("unix://");
+            return { provider, installed: true, version, interactiveTransport: supported ? "codex_app_server" : undefined, reason: supported ? undefined : "Installed Codex does not advertise the app-server transports Hive requires." };
+        }
+        const supported = help.includes("--input-format") && help.includes("stream-json") && help.includes("--output-format");
+        return { provider, installed: true, version, interactiveTransport: supported ? "claude_stream_json" : undefined, reason: supported ? undefined : "Installed Claude does not advertise bidirectional stream-json mode." };
+    }
+    catch (cause) {
+        return { provider, installed: false, reason: cause.message };
+    }
+}
+let cached;
+/** Detect once per server process; CLI help can touch keychains and must not run per request. */
+export function providerTerminalCatalog() {
+    return cached ??= { claude: detectProviderTerminal("claude"), codex: detectProviderTerminal("codex") };
+}
+export function resetProviderTerminalCatalogForTest() { cached = undefined; }

package/packages/server/dist/terminals/terminalCapability.js

@@ -0,0 +1,45 @@
+import { providerTerminalCatalog } from "./providerDetection.js";
+import { terminalFeatureFlags } from "./terminalFeatures.js";
+/**
+ * What input the current transcript source can honestly accept.
+ *
+ * Hive currently reconstructs output from provider transcript files; it does
+ * not own a PTY. Manager follow-ups are still real input, but they start or
+ * resume a provider turn instead of typing into the process shown above.
+ */
+export function terminalCapability(source, provider, lifecycle, detection = providerTerminalCatalog()[provider], providerTurnActive = false, features = terminalFeatureFlags()) {
+    const detected = { provider, providerVersion: detection.version, detectedInteractiveTransport: detection.interactiveTransport };
+    if (source.kind === "worker") {
+        return { ...detected, mode: "read_only", connected: false, acceptsInterrupt: false, acceptsResize: false, reason: "Worker transcripts do not expose a safe input channel." };
+    }
+    if (lifecycle === "completed" || lifecycle === "archived") {
+        return { ...detected, mode: "read_only", connected: false, acceptsInterrupt: false, acceptsResize: false, reason: "This mission is finished. Reopen it from Conversation before sending another turn." };
+    }
+    if (provider === "codex" && !features.codexInput) {
+        return { ...detected, mode: "read_only", connected: false, acceptsInterrupt: false, acceptsResize: false, reason: "Writable Codex Terminal input is disabled by HIVE_TERMINAL_CODEX_INPUT." };
+    }
+    if (provider === "claude" && !features.claudeFollowUp) {
+        return { ...detected, mode: "read_only", connected: false, acceptsInterrupt: false, acceptsResize: false, reason: "Claude Terminal follow-ups are disabled by HIVE_TERMINAL_CLAUDE_FOLLOW_UP. Conversation remains available." };
+    }
+    if (providerTurnActive) {
+        return { ...detected, mode: "read_only", connected: true, acceptsInterrupt: false, acceptsResize: false, reason: "The current provider turn is still running. Input becomes available when it finishes." };
+    }
+    if (provider === "codex" && detection.interactiveTransport === "codex_app_server") {
+        return {
+            ...detected,
+            mode: "interactive",
+            connected: true,
+            acceptsInterrupt: true,
+            acceptsResize: false,
+            reason: "Input starts a live Codex app-server turn in this mission thread.",
+        };
+    }
+    return {
+        ...detected,
+        mode: "follow_up",
+        connected: true,
+        acceptsInterrupt: false,
+        acceptsResize: false,
+        reason: `Sends a new ${provider === "codex" ? "Codex" : "Claude"} turn; it is not live terminal stdin.`,
+    };
+}

package/packages/server/dist/terminals/terminalFeatures.js

@@ -0,0 +1,11 @@
+function enabled(value, fallback = true) {
+    if (value === undefined)
+        return fallback;
+    return !["0", "false", "off", "no"].includes(value.trim().toLowerCase());
+}
+export function terminalFeatureFlags(env = process.env) {
+    return {
+        codexInput: enabled(env.HIVE_TERMINAL_CODEX_INPUT),
+        claudeFollowUp: enabled(env.HIVE_TERMINAL_CLAUDE_FOLLOW_UP),
+    };
+}

package/packages/server/dist/terminals/terminalObservability.js

@@ -0,0 +1,21 @@
+/** Privacy-safe local counters and bounded audit metadata; raw input never enters this object. */
+export class TerminalObservability {
+    onAudit;
+    auditLimit;
+    counters = new Map();
+    recent = [];
+    constructor(onAudit, auditLimit = 200) {
+        this.onAudit = onAudit;
+        this.auditLimit = auditLimit;
+    }
+    metric(name) { this.counters.set(name, (this.counters.get(name) ?? 0) + 1); }
+    input(record) {
+        const entry = { ts: Date.now(), ...record };
+        this.recent.push(entry);
+        if (this.recent.length > this.auditLimit)
+            this.recent.splice(0, this.recent.length - this.auditLimit);
+        this.metric(`input.${record.provider}.${record.outcome}`);
+        this.onAudit?.(entry);
+    }
+    snapshot() { return { counters: Object.fromEntries(this.counters), recentInputOperations: this.recent.map((entry) => ({ ...entry })) }; }
+}

package/packages/server/dist/terminals/terminalRuntime.js

@@ -0,0 +1,125 @@
+import { createHash } from "node:crypto";
+import { CodexAppServerClient } from "./codexAppServerClient.js";
+import { TerminalStream } from "./terminalStream.js";
+import { TerminalObservability } from "./terminalObservability.js";
+/** Owns interactive Codex turns without changing the legacy mission launcher. */
+export class TerminalRuntime {
+    connectCodex;
+    observability;
+    stream;
+    active = new Map();
+    receipts = new Map();
+    pendingInputs = new Map();
+    launching = new Set();
+    constructor(stream = new TerminalStream(), connectCodex = (threadId, options) => CodexAppServerClient.reconnectStdio(threadId, options), observability = new TerminalObservability()) {
+        this.connectCodex = connectCodex;
+        this.observability = observability;
+        this.stream = stream;
+    }
+    async submitCodex(input) {
+        const audit = (outcome, reason) => this.observability.input({ missionId: input.missionId, source: input.source, provider: "codex", inputCharacters: input.text.length, outcome, reason });
+        audit("attempted");
+        const receiptKey = `${input.missionId}:${input.source}:${input.clientInputId}`;
+        const digest = createHash("sha256").update(input.text).digest("hex");
+        const prior = this.receipts.get(receiptKey);
+        if (prior) {
+            if (prior.digest !== digest) {
+                audit("failed", "client_input_id_content_mismatch");
+                throw new Error("clientInputId was already used for different terminal input");
+            }
+            audit("duplicate", "replayed_client_input_id");
+            return { ...prior.receipt, status: "duplicate" };
+        }
+        const pending = this.pendingInputs.get(receiptKey);
+        if (pending) {
+            if (pending.digest !== digest) {
+                audit("failed", "client_input_id_content_mismatch");
+                throw new Error("clientInputId is already being used for different terminal input");
+            }
+            const receipt = await pending.promise;
+            audit("duplicate", "coalesced_client_input_id");
+            return { ...receipt, status: "duplicate" };
+        }
+        if (this.active.has(input.missionId) || this.launching.has(input.missionId)) {
+            audit("failed", "turn_already_running");
+            throw new Error("An interactive terminal turn is already running for this mission");
+        }
+        this.launching.add(input.missionId);
+        const operation = this.startCodex(input, receiptKey);
+        this.pendingInputs.set(receiptKey, { promise: operation, digest });
+        try {
+            const receipt = await operation;
+            audit("accepted");
+            return receipt;
+        }
+        catch (error) {
+            audit("failed", "provider_input_failed");
+            throw error;
+        }
+        finally {
+            this.pendingInputs.delete(receiptKey);
+            this.launching.delete(input.missionId);
+        }
+    }
+    async startCodex(input, receiptKey) {
+        this.observability.metric("connection.codex.reconnect_attempt");
+        const client = await this.connectCodex(input.threadId, { cwd: input.cwd, model: input.model, approvalPolicy: "never", sandbox: input.policy.allowedRoots.length ? "workspace-write" : "read-only" });
+        this.observability.metric("connection.codex.connected");
+        let completedEarly = false;
+        const unsubscribe = client.onNotification((notification) => {
+            this.publishNotification(input.missionId, input.source, notification);
+            if (notification.method !== "turn/completed" && notification.method !== "error" && notification.method !== "hive/connection/closed")
+                return;
+            if (notification.method === "hive/connection/closed")
+                this.observability.metric("cleanup.codex.provider_exit");
+            if (this.active.has(input.missionId))
+                this.finish(input.missionId);
+            else
+                completedEarly = true;
+        });
+        try {
+            const turn = await client.startTurn(input.threadId, input.text);
+            const accepted = this.stream.publish({ missionId: input.missionId, source: input.source, method: "hive/input/accepted", params: { clientInputId: input.clientInputId, turnId: turn.turnId } });
+            const receipt = { clientInputId: input.clientInputId, status: "accepted", streamId: accepted.streamId, sequence: accepted.sequence, turnId: turn.turnId };
+            this.receipts.set(receiptKey, { receipt, digest: createHash("sha256").update(input.text).digest("hex") });
+            this.trimReceipts();
+            if (completedEarly) {
+                unsubscribe();
+                client.close();
+            }
+            else
+                this.active.set(input.missionId, { client, threadId: input.threadId, turnId: turn.turnId, unsubscribe });
+            return receipt;
+        }
+        catch (error) {
+            unsubscribe();
+            client.close();
+            throw error;
+        }
+    }
+    async interrupt(missionId) {
+        const active = this.active.get(missionId);
+        if (!active)
+            throw new Error("No interactive terminal turn is running for this mission");
+        await active.client.interruptTurn(active.threadId, active.turnId);
+        this.observability.metric("interrupt.codex.accepted");
+    }
+    close() { for (const missionId of [...this.active.keys()]) {
+        this.observability.metric("cleanup.codex.server_shutdown");
+        this.finish(missionId);
+    } }
+    publishNotification(missionId, source, notification) {
+        this.stream.publish({ missionId, source, method: notification.method, params: boundedParams(notification.params) });
+    }
+    finish(missionId) { const active = this.active.get(missionId); if (!active)
+        return; this.active.delete(missionId); active.unsubscribe(); active.client.close(); }
+    trimReceipts() { while (this.receipts.size > 2_000)
+        this.receipts.delete(this.receipts.keys().next().value); }
+}
+/** Never retain an unbounded notification object in the reconnect buffer. */
+function boundedParams(params) {
+    if (!params)
+        return undefined;
+    const json = JSON.stringify(params);
+    return json.length <= 64_000 ? params : { truncated: true, preview: json.slice(0, 64_000) };
+}

package/packages/server/dist/terminals/terminalStream.js

@@ -0,0 +1,30 @@
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+/** Bounded in-memory live stream; durable transcripts remain the restart fallback. */
+export class TerminalStream {
+    limit;
+    streamId = randomUUID();
+    sequence = 0;
+    events = [];
+    emitter = new EventEmitter();
+    constructor(limit = 2_000) {
+        this.limit = limit;
+    }
+    publish(input) {
+        const event = { ...input, streamId: this.streamId, sequence: ++this.sequence, ts: input.ts ?? Date.now() };
+        this.events.push(event);
+        if (this.events.length > this.limit)
+            this.events.splice(0, this.events.length - this.limit);
+        this.emitter.emit("event", event);
+        return event;
+    }
+    replay(missionId, source, after = 0) {
+        const matching = this.events.filter((event) => event.missionId === missionId && event.source === source);
+        const oldestRetained = this.events[0]?.sequence;
+        return { streamId: this.streamId, events: matching.filter((event) => event.sequence > after), truncated: oldestRetained !== undefined && after < oldestRetained - 1, latestSequence: this.sequence };
+    }
+    onEvent(listener) {
+        this.emitter.on("event", listener);
+        return () => this.emitter.off("event", listener);
+    }
+}