consensus-cli 0.1.0 → 0.1.4

package/CHANGELOG.md

@@ -5,6 +5,27 @@ This project follows Semantic Versioning.
 
 ## Unreleased
 
+## 0.1.4 - 2026-01-24
+- Fix OpenCode event tracking build error (pid activity typing).
+
+## 0.1.3 - 2026-01-24
+- Add OpenCode integration (API sessions, event stream, storage fallback).
+- Autostart OpenCode server with opt-out and CLI flags.
+- Split servers into a dedicated lane with distinct palette.
+- Improve layout keys to prevent tile overlap.
+- Add OpenCode unit/integration tests and configuration docs.
+
+## 0.1.2 - 2026-01-24
+- Lower CPU threshold for active detection.
+- Increase activity window defaults for long-running turns.
+- Skip vendor codex helper processes to avoid duplicate tiles.
+- Improve session mapping for active-state detection.
+
+## 0.1.1 - 2026-01-24
+- Smooth active state to prevent animation flicker.
+- Add `consensus-cli` binary alias so `npx consensus-cli` works.
+- Extend active window to match Codex event cadence.
+
 ## 0.1.0 - 2026-01-24
 - Initial public release.
 - Improve work summaries and recent events (latest-first, event-only fallback).

package/README.md

@@ -62,10 +62,15 @@ consensus dev server running on http://127.0.0.1:8787
 - `CONSENSUS_PORT`: server port (default `8787`).
 - `CONSENSUS_POLL_MS`: polling interval in ms (default `1000`).
 - `CONSENSUS_CODEX_HOME`: override Codex home (default `~/.codex`).
+- `CONSENSUS_OPENCODE_HOST`: OpenCode server host (default `127.0.0.1`).
+- `CONSENSUS_OPENCODE_PORT`: OpenCode server port (default `4096`).
+- `CONSENSUS_OPENCODE_AUTOSTART`: set to `0` to disable OpenCode autostart.
+- `CONSENSUS_OPENCODE_EVENTS`: set to `0` to disable OpenCode event stream.
 - `CONSENSUS_PROCESS_MATCH`: regex to match codex processes.
 - `CONSENSUS_REDACT_PII`: set to `0` to disable redaction (default enabled).
-- `CONSENSUS_EVENT_ACTIVE_MS`: active window after last event in ms (default `8000`).
-- `CONSENSUS_CPU_ACTIVE`: CPU threshold for active state (default `5`).
+- `CONSENSUS_EVENT_ACTIVE_MS`: active window after last event in ms (default `300000`).
+- `CONSENSUS_CPU_ACTIVE`: CPU threshold for active state (default `1`).
+- `CONSENSUS_ACTIVE_HOLD_MS`: keep active state this long after activity (default `600000`).
 
 Full config details: `docs/configuration.md`
 

package/dist/activity.js

@@ -1,5 +1,6 @@
-const DEFAULT_CPU_THRESHOLD = 5;
-const DEFAULT_EVENT_WINDOW_MS = 8000;
+const DEFAULT_CPU_THRESHOLD = 1;
+const DEFAULT_EVENT_WINDOW_MS = 300000;
+const DEFAULT_ACTIVE_HOLD_MS = 600000;
 export function deriveState(input) {
     if (input.hasError)
         return "error";
@@ -10,5 +11,21 @@ export function deriveState(input) {
     const cpuActive = input.cpu > cpuThreshold;
     const eventActive = typeof input.lastEventAt === "number" &&
         now - input.lastEventAt <= eventWindowMs;
-    return cpuActive || eventActive ? "active" : "idle";
+    const inFlight = !!input.inFlight;
+    return cpuActive || eventActive || inFlight ? "active" : "idle";
+}
+export function deriveStateWithHold(input) {
+    const now = input.now ?? Date.now();
+    const holdMs = input.holdMs ?? Number(process.env.CONSENSUS_ACTIVE_HOLD_MS || DEFAULT_ACTIVE_HOLD_MS);
+    const baseState = deriveState({ ...input, now });
+    let lastActiveAt = input.previousActiveAt;
+    if (baseState === "active") {
+        lastActiveAt = now;
+    }
+    if (baseState === "idle" &&
+        typeof lastActiveAt === "number" &&
+        now - lastActiveAt <= holdMs) {
+        return { state: "active", lastActiveAt };
+    }
+    return { state: baseState, lastActiveAt };
 }

package/dist/cli.js

@@ -27,6 +27,9 @@ function printHelp() {
     process.stdout.write(`  --port <port>        Port (default 8787)\n`);
     process.stdout.write(`  --poll <ms>          Poll interval in ms\n`);
     process.stdout.write(`  --codex-home <path>  Override CODEX_HOME\n`);
+    process.stdout.write(`  --opencode-host <h>  OpenCode host (default 127.0.0.1)\n`);
+    process.stdout.write(`  --opencode-port <p>  OpenCode port (default 4096)\n`);
+    process.stdout.write(`  --no-opencode-autostart  Disable OpenCode server autostart\n`);
     process.stdout.write(`  --process-match <re> Regex for process matching\n`);
     process.stdout.write(`  --no-redact          Disable PII redaction\n`);
     process.stdout.write(`  -h, --help           Show help\n`);
@@ -40,6 +43,9 @@ const host = readArg("--host");
 const port = readArg("--port");
 const poll = readArg("--poll");
 const codexHome = readArg("--codex-home");
+const opencodeHost = readArg("--opencode-host");
+const opencodePort = readArg("--opencode-port");
+const noOpenCodeAutostart = hasFlag("--no-opencode-autostart");
 const match = readArg("--process-match");
 const noRedact = hasFlag("--no-redact");
 if (host)
@@ -50,6 +56,12 @@ if (poll)
     env.CONSENSUS_POLL_MS = poll;
 if (codexHome)
     env.CONSENSUS_CODEX_HOME = codexHome;
+if (opencodeHost)
+    env.CONSENSUS_OPENCODE_HOST = opencodeHost;
+if (opencodePort)
+    env.CONSENSUS_OPENCODE_PORT = opencodePort;
+if (noOpenCodeAutostart)
+    env.CONSENSUS_OPENCODE_AUTOSTART = "0";
 if (match)
     env.CONSENSUS_PROCESS_MATCH = match;
 if (noRedact)

package/dist/codexLogs.js

@@ -4,11 +4,14 @@ import path from "path";
 import { redactText } from "./redact.js";
 const SESSION_WINDOW_MS = 30 * 60 * 1000;
 const SESSION_SCAN_INTERVAL_MS = 5000;
+const SESSION_ID_SCAN_INTERVAL_MS = 60000;
 const MAX_READ_BYTES = 512 * 1024;
 const MAX_EVENTS = 50;
 let cachedSessions = [];
 let lastSessionScan = 0;
 const tailStates = new Map();
+const sessionIdCache = new Map();
+const sessionIdLastScan = new Map();
 export function resolveCodexHome(env = process.env) {
     const override = env.CONSENSUS_CODEX_HOME || env.CODEX_HOME;
     return override ? path.resolve(override) : path.join(os.homedir(), ".codex");
@@ -41,6 +44,36 @@ async function walk(dir, out, windowMs) {
         }
     }));
 }
+async function findSessionFile(dir, sessionId) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            const found = await findSessionFile(fullPath, sessionId);
+            if (found)
+                return found;
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith(".jsonl"))
+            continue;
+        if (!entry.name.includes(sessionId))
+            continue;
+        try {
+            const stat = await fsp.stat(fullPath);
+            return { path: fullPath, mtimeMs: stat.mtimeMs };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
 export async function listRecentSessions(codexHome, windowMs = SESSION_WINDOW_MS) {
     const now = Date.now();
     if (now - lastSessionScan < SESSION_SCAN_INTERVAL_MS) {
@@ -54,6 +87,28 @@ export async function listRecentSessions(codexHome, windowMs = SESSION_WINDOW_MS
     cachedSessions = results;
     return results;
 }
+export async function findSessionById(codexHome, sessionId) {
+    const now = Date.now();
+    const lastScan = sessionIdLastScan.get(sessionId) || 0;
+    if (now - lastScan < SESSION_ID_SCAN_INTERVAL_MS) {
+        const cached = sessionIdCache.get(sessionId);
+        if (cached) {
+            try {
+                const stat = await fsp.stat(cached);
+                return { path: cached, mtimeMs: stat.mtimeMs };
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    sessionIdLastScan.set(sessionId, now);
+    const sessionsDir = path.join(codexHome, "sessions");
+    const found = await findSessionFile(sessionsDir, sessionId);
+    sessionIdCache.set(sessionId, found ? found.path : null);
+    return found;
+}
 export function pickSessionForProcess(sessions, startTimeMs) {
     if (sessions.length === 0)
         return undefined;
@@ -256,6 +311,8 @@ export async function updateTail(sessionPath) {
     const combined = state.partial + text;
     const lines = combined.split(/\r?\n/);
     state.partial = lines.pop() || "";
+    const startRe = /(turn|item|response)\.started/i;
+    const endRe = /(turn|item|response)\.(completed|failed|errored)/i;
     for (const line of lines) {
         if (!line.trim())
             continue;
@@ -270,6 +327,12 @@ export async function updateTail(sessionPath) {
         const { summary, kind, isError, model, type } = summarizeEvent(ev);
         if (model)
             state.model = model;
+        if (typeof type === "string") {
+            if (startRe.test(type))
+                state.inFlight = true;
+            if (endRe.test(type))
+                state.inFlight = false;
+        }
         if (summary) {
             const entry = {
                 ts,
@@ -328,5 +391,14 @@ export function summarizeTail(state) {
         lastTool: state.lastTool?.summary,
         lastPrompt: state.lastPrompt?.summary,
     };
-    return { doing, title, events, model: state.model, hasError, summary, lastEventAt };
+    return {
+        doing,
+        title,
+        events,
+        model: state.model,
+        hasError,
+        summary,
+        lastEventAt,
+        inFlight: state.inFlight,
+    };
 }

package/dist/opencodeApi.js

@@ -0,0 +1,84 @@
+function shouldWarn(options) {
+    return options?.silent ? false : true;
+}
+export async function getOpenCodeSessions(host = "localhost", port = 4096, options) {
+    const controller = new AbortController();
+    const timeoutMs = options?.timeoutMs ?? 5000;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const warn = shouldWarn(options);
+    try {
+        const response = await fetch(`http://${host}:${port}/session`, {
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "consensus-scanner",
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            if (warn) {
+                console.warn(`OpenCode API error: ${response.status} ${response.statusText}`);
+            }
+            return { ok: false, sessions: [], status: response.status, reachable: true };
+        }
+        const contentType = response.headers.get("content-type") || "";
+        if (!contentType.includes("json")) {
+            if (warn) {
+                console.warn(`OpenCode API non-JSON response (${contentType || "unknown"})`);
+            }
+            return { ok: false, sessions: [], status: response.status, reachable: true, error: "non_json" };
+        }
+        const payload = await response.json();
+        if (Array.isArray(payload))
+            return { ok: true, sessions: payload, reachable: true };
+        if (payload && typeof payload === "object" && Array.isArray(payload.sessions)) {
+            return { ok: true, sessions: payload.sessions, reachable: true };
+        }
+        if (payload && typeof payload === "object" && Array.isArray(payload.data)) {
+            return { ok: true, sessions: payload.data, reachable: true };
+        }
+        return { ok: true, sessions: [], reachable: true };
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (warn) {
+            console.warn("Failed to fetch OpenCode sessions:", error);
+        }
+        const errorCode = typeof error?.cause?.code === "string"
+            ? error.cause.code
+            : typeof error?.code === "string"
+                ? error.code
+                : undefined;
+        return { ok: false, sessions: [], error: errorCode, reachable: false };
+    }
+}
+export async function getOpenCodeSession(sessionId, host = "localhost", port = 4096, options) {
+    const controller = new AbortController();
+    const timeoutMs = options?.timeoutMs ?? 5000;
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const warn = shouldWarn(options);
+    try {
+        const response = await fetch(`http://${host}:${port}/session/${sessionId}`, {
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "consensus-scanner",
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            if (warn) {
+                console.warn(`OpenCode API error for session ${sessionId}: ${response.status} ${response.statusText}`);
+            }
+            return null;
+        }
+        return await response.json();
+    }
+    catch (error) {
+        clearTimeout(timeoutId);
+        if (warn) {
+            console.warn(`Failed to fetch OpenCode session ${sessionId}:`, error);
+        }
+        return null;
+    }
+}

package/dist/opencodeEvents.js

@@ -0,0 +1,359 @@
+import { redactText } from "./redact.js";
+const MAX_EVENTS = 50;
+const STALE_TTL_MS = 30 * 60 * 1000;
+const RECONNECT_MIN_MS = 10000;
+const sessionActivity = new Map();
+const pidActivity = new Map();
+let connecting = false;
+let connected = false;
+let lastConnectAt = 0;
+let lastFailureAt = 0;
+function nowMs() {
+    return Date.now();
+}
+function parseTimestamp(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 100000000000 ? value * 1000 : value;
+    }
+    if (typeof value === "string") {
+        const parsed = Date.parse(value);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return nowMs();
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value))
+        return value.map(extractText).filter(Boolean).join(" ");
+    if (value && typeof value === "object") {
+        if (typeof value.text === "string")
+            return value.text;
+        if (typeof value.content === "string")
+            return value.content;
+        if (typeof value.message === "string")
+            return value.message;
+        if (value.message && typeof value.message.content === "string") {
+            return value.message.content;
+        }
+    }
+    return undefined;
+}
+function getSessionId(raw) {
+    return (raw?.sessionId ||
+        raw?.session_id ||
+        raw?.session?.id ||
+        raw?.session?.sessionId ||
+        raw?.properties?.sessionId ||
+        raw?.properties?.session_id);
+}
+function getPid(raw) {
+    const pid = raw?.pid ||
+        raw?.process?.pid ||
+        raw?.properties?.pid ||
+        raw?.properties?.processId;
+    if (typeof pid === "number" && Number.isFinite(pid))
+        return pid;
+    if (typeof pid === "string") {
+        const parsed = Number(pid);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function summarizeEvent(raw) {
+    const typeRaw = raw?.type ||
+        raw?.event ||
+        raw?.name ||
+        raw?.kind ||
+        raw?.properties?.type ||
+        "event";
+    const type = typeof typeRaw === "string" ? typeRaw : "event";
+    const lowerType = type.toLowerCase();
+    const status = raw?.status || raw?.state || raw?.properties?.status;
+    const statusStr = typeof status === "string" ? status.toLowerCase() : "";
+    const isError = !!raw?.error || lowerType.includes("error") || statusStr.includes("error");
+    let inFlight;
+    if (lowerType.includes("started") ||
+        statusStr.includes("started") ||
+        statusStr.includes("running") ||
+        statusStr.includes("processing") ||
+        statusStr.includes("in_progress")) {
+        inFlight = true;
+    }
+    else if (lowerType.includes("completed") ||
+        lowerType.includes("finished") ||
+        lowerType.includes("done") ||
+        lowerType.includes("ended") ||
+        statusStr.includes("completed") ||
+        statusStr.includes("finished") ||
+        statusStr.includes("done") ||
+        statusStr.includes("ended") ||
+        statusStr.includes("idle") ||
+        statusStr.includes("stopped") ||
+        statusStr.includes("paused") ||
+        isError) {
+        inFlight = false;
+    }
+    if (lowerType.includes("compaction")) {
+        const phase = statusStr || raw?.phase || raw?.properties?.phase;
+        const summary = phase ? `compaction: ${phase}` : "compaction";
+        return { summary, kind: "other", isError, type, inFlight };
+    }
+    const cmd = raw?.command ||
+        raw?.cmd ||
+        raw?.input?.command ||
+        raw?.input?.cmd ||
+        raw?.properties?.command ||
+        raw?.properties?.cmd ||
+        (Array.isArray(raw?.args) ? raw.args.join(" ") : undefined);
+    if (typeof cmd === "string" && cmd.trim()) {
+        const summary = redactText(`cmd: ${cmd.trim()}`) || `cmd: ${cmd.trim()}`;
+        return { summary, kind: "command", isError, type, inFlight };
+    }
+    const pathHint = raw?.path ||
+        raw?.file ||
+        raw?.filename ||
+        raw?.target ||
+        raw?.properties?.path ||
+        raw?.properties?.file;
+    if (typeof pathHint === "string" && pathHint.trim() && lowerType.includes("file")) {
+        const summary = redactText(`edit: ${pathHint.trim()}`) || `edit: ${pathHint.trim()}`;
+        return { summary, kind: "edit", isError, type };
+    }
+    const tool = raw?.tool ||
+        raw?.tool_name ||
+        raw?.toolName ||
+        raw?.properties?.tool ||
+        raw?.properties?.tool_name;
+    if (typeof tool === "string" && tool.trim() && lowerType.includes("tool")) {
+        const summary = redactText(`tool: ${tool.trim()}`) || `tool: ${tool.trim()}`;
+        return { summary, kind: "tool", isError, type, inFlight };
+    }
+    const promptText = extractText(raw?.prompt) ||
+        extractText(raw?.input) ||
+        extractText(raw?.instruction) ||
+        extractText(raw?.properties?.prompt);
+    if (promptText && lowerType.includes("prompt")) {
+        const trimmed = promptText.replace(/\s+/g, " ").trim();
+        const snippet = trimmed.slice(0, 120);
+        const summary = redactText(`prompt: ${snippet}`) || `prompt: ${snippet}`;
+        return { summary, kind: "prompt", isError, type };
+    }
+    const messageText = extractText(raw?.message) ||
+        extractText(raw?.content) ||
+        extractText(raw?.text) ||
+        extractText(raw?.properties?.message);
+    if (messageText) {
+        const trimmed = messageText.replace(/\s+/g, " ").trim();
+        const snippet = trimmed.slice(0, 80);
+        const summary = redactText(snippet) || snippet;
+        return { summary, kind: "message", isError, type };
+    }
+    if (type && type !== "event") {
+        const summary = redactText(`event: ${type}`) || `event: ${type}`;
+        return { summary, kind: "other", isError, type };
+    }
+    return { kind: "other", isError, type };
+}
+function ensureActivity(key, map, now) {
+    const existing = map.get(key);
+    if (existing) {
+        existing.lastSeenAt = now;
+        return existing;
+    }
+    const fresh = {
+        events: [],
+        summary: {},
+        lastSeenAt: now,
+    };
+    map.set(key, fresh);
+    return fresh;
+}
+function recordEvent(state, entry, kind) {
+    state.events.push(entry);
+    if (state.events.length > MAX_EVENTS) {
+        state.events = state.events.slice(-MAX_EVENTS);
+    }
+    state.lastEventAt = Math.max(state.lastEventAt || 0, entry.ts);
+    if (kind === "command")
+        state.lastCommand = entry;
+    if (kind === "edit")
+        state.lastEdit = entry;
+    if (kind === "message")
+        state.lastMessage = entry;
+    if (kind === "tool")
+        state.lastTool = entry;
+    if (kind === "prompt")
+        state.lastPrompt = entry;
+    if (entry.isError)
+        state.lastError = entry;
+    state.summary = {
+        current: state.events[state.events.length - 1]?.summary,
+        lastCommand: state.lastCommand?.summary,
+        lastEdit: state.lastEdit?.summary,
+        lastMessage: state.lastMessage?.summary,
+        lastTool: state.lastTool?.summary,
+        lastPrompt: state.lastPrompt?.summary,
+    };
+}
+function handleRawEvent(raw) {
+    const ts = parseTimestamp(raw?.ts ||
+        raw?.timestamp ||
+        raw?.time ||
+        raw?.created_at ||
+        raw?.createdAt ||
+        raw?.properties?.time ||
+        raw?.properties?.timestamp);
+    const sessionId = getSessionId(raw);
+    const pid = getPid(raw);
+    const { summary, kind, isError, type, inFlight } = summarizeEvent(raw);
+    if (!summary)
+        return;
+    const entry = {
+        ts,
+        type: typeof type === "string" ? type : "event",
+        summary,
+        isError,
+    };
+    const now = nowMs();
+    if (sessionId) {
+        const state = ensureActivity(sessionId, sessionActivity, now);
+        recordEvent(state, entry, kind);
+        if (typeof inFlight === "boolean")
+            state.inFlight = inFlight;
+    }
+    if (typeof pid === "number") {
+        const state = ensureActivity(pid, pidActivity, now);
+        recordEvent(state, entry, kind);
+        if (typeof inFlight === "boolean")
+            state.inFlight = inFlight;
+    }
+}
+function pruneStale() {
+    const cutoff = nowMs() - STALE_TTL_MS;
+    for (const [key, state] of sessionActivity.entries()) {
+        if (state.lastSeenAt < cutoff)
+            sessionActivity.delete(key);
+    }
+    for (const [key, state] of pidActivity.entries()) {
+        if (state.lastSeenAt < cutoff)
+            pidActivity.delete(key);
+    }
+}
+async function connectStream(host, port) {
+    connecting = true;
+    lastConnectAt = nowMs();
+    try {
+        const response = await fetch(`http://${host}:${port}/global/event`, {
+            headers: {
+                Accept: "text/event-stream",
+            },
+        });
+        if (!response.ok || !response.body) {
+            connected = false;
+            connecting = false;
+            lastFailureAt = nowMs();
+            return;
+        }
+        connected = true;
+        connecting = false;
+        const reader = response.body.getReader();
+        let buffer = "";
+        let currentEvent;
+        let dataLines = [];
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += Buffer.from(value).toString("utf8");
+            let idx;
+            while ((idx = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, idx).trimEnd();
+                buffer = buffer.slice(idx + 1);
+                if (!line) {
+                    if (dataLines.length) {
+                        const payload = dataLines.join("\n");
+                        try {
+                            const parsed = JSON.parse(payload);
+                            const raw = parsed?.payload ?? parsed;
+                            if (currentEvent && typeof raw === "object" && !raw.type) {
+                                raw.type = currentEvent;
+                            }
+                            if (parsed?.type && typeof raw === "object" && !raw.type) {
+                                raw.type = parsed.type;
+                            }
+                            handleRawEvent(raw);
+                        }
+                        catch {
+                            // ignore malformed payloads
+                        }
+                    }
+                    currentEvent = undefined;
+                    dataLines = [];
+                    continue;
+                }
+                if (line.startsWith("event:")) {
+                    currentEvent = line.slice(6).trim();
+                    continue;
+                }
+                if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trim());
+                }
+            }
+        }
+    }
+    catch {
+        lastFailureAt = nowMs();
+    }
+    finally {
+        connected = false;
+        connecting = false;
+    }
+}
+export function ensureOpenCodeEventStream(host, port) {
+    if (process.env.CONSENSUS_OPENCODE_EVENTS === "0")
+        return;
+    const now = nowMs();
+    if (connecting || connected)
+        return;
+    if (now - lastConnectAt < RECONNECT_MIN_MS)
+        return;
+    if (now - lastFailureAt < RECONNECT_MIN_MS)
+        return;
+    pruneStale();
+    void connectStream(host, port);
+}
+export function getOpenCodeActivityBySession(sessionId) {
+    if (!sessionId)
+        return null;
+    const state = sessionActivity.get(sessionId);
+    if (!state)
+        return null;
+    const events = state.events.slice(-20);
+    const hasError = !!state.lastError || events.some((ev) => ev.isError);
+    return {
+        events,
+        summary: state.summary,
+        lastEventAt: state.lastEventAt,
+        hasError,
+        inFlight: state.inFlight,
+    };
+}
+export function getOpenCodeActivityByPid(pid) {
+    if (typeof pid !== "number")
+        return null;
+    const state = pidActivity.get(pid);
+    if (!state)
+        return null;
+    const events = state.events.slice(-20);
+    const hasError = !!state.lastError || events.some((ev) => ev.isError);
+    return {
+        events,
+        summary: state.summary,
+        lastEventAt: state.lastEventAt,
+        hasError,
+        inFlight: state.inFlight,
+    };
+}