consensus-cli 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -5,6 +5,16 @@ 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.

package/README.md

@@ -62,6 +62,10 @@ 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 `300000`).

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/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,
+    };
+}

package/dist/opencodeServer.js

@@ -0,0 +1,91 @@
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+import { getOpenCodeSessions } from "./opencodeApi.js";
+const execFileAsync = promisify(execFile);
+const AUTOSTART_ENABLED = process.env.CONSENSUS_OPENCODE_AUTOSTART !== "0";
+const CHECK_INTERVAL_MS = 30000;
+const INSTALL_CHECK_INTERVAL_MS = 5 * 60000;
+const START_BACKOFF_MS = 60000;
+let lastAttemptAt = 0;
+let lastInstallCheck = 0;
+let lastStartAt = 0;
+let opencodeInstalled = null;
+let startedPid = null;
+let startInFlight = false;
+async function isOpenCodeInstalled() {
+    const now = Date.now();
+    if (opencodeInstalled !== null && now - lastInstallCheck < INSTALL_CHECK_INTERVAL_MS) {
+        return opencodeInstalled;
+    }
+    lastInstallCheck = now;
+    try {
+        await execFileAsync("opencode", ["--version"]);
+        opencodeInstalled = true;
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            opencodeInstalled = false;
+        }
+        else {
+            opencodeInstalled = true;
+        }
+    }
+    return opencodeInstalled;
+}
+function spawnOpenCodeServer(host, port) {
+    if (startInFlight)
+        return;
+    startInFlight = true;
+    const child = spawn("opencode", ["serve", "--hostname", host, "--port", String(port)], {
+        stdio: "ignore",
+        detached: true,
+    });
+    child.unref();
+    startedPid = child.pid ?? null;
+    child.on("error", () => {
+        startInFlight = false;
+    });
+    child.on("spawn", () => {
+        startInFlight = false;
+    });
+}
+export async function ensureOpenCodeServer(host, port, existingResult) {
+    if (!AUTOSTART_ENABLED)
+        return;
+    const now = Date.now();
+    if (now - lastAttemptAt < CHECK_INTERVAL_MS)
+        return;
+    lastAttemptAt = now;
+    const installed = await isOpenCodeInstalled();
+    if (!installed)
+        return;
+    const result = existingResult ?? (await getOpenCodeSessions(host, port, { silent: true }));
+    if (result.ok)
+        return;
+    if (result.reachable)
+        return;
+    if (now - lastStartAt < START_BACKOFF_MS)
+        return;
+    lastStartAt = now;
+    spawnOpenCodeServer(host, port);
+}
+function stopOpenCodeServer() {
+    if (!startedPid)
+        return;
+    try {
+        process.kill(startedPid);
+    }
+    catch {
+        // ignore failures
+    }
+    startedPid = null;
+}
+process.on("exit", stopOpenCodeServer);
+process.on("SIGINT", () => {
+    stopOpenCodeServer();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    stopOpenCodeServer();
+    process.exit(0);
+});

package/dist/opencodeStorage.js

@@ -0,0 +1,127 @@
+import fsp from "fs/promises";
+import os from "os";
+import path from "path";
+const PROJECT_SCAN_INTERVAL_MS = 60000;
+const SESSION_SCAN_INTERVAL_MS = 5000;
+let projectCache = [];
+let projectCacheAt = 0;
+const sessionCache = new Map();
+export function resolveOpenCodeHome(env = process.env) {
+    const override = env.CONSENSUS_OPENCODE_HOME;
+    if (override)
+        return path.resolve(override);
+    return path.join(os.homedir(), ".local", "share", "opencode");
+}
+async function listProjectEntries(home) {
+    const now = Date.now();
+    if (now - projectCacheAt < PROJECT_SCAN_INTERVAL_MS)
+        return projectCache;
+    projectCacheAt = now;
+    const projectDir = path.join(home, "storage", "project");
+    let entries;
+    try {
+        entries = await fsp.readdir(projectDir, { withFileTypes: true });
+    }
+    catch {
+        projectCache = [];
+        return projectCache;
+    }
+    const results = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json"))
+            continue;
+        const fullPath = path.join(projectDir, entry.name);
+        try {
+            const raw = await fsp.readFile(fullPath, "utf8");
+            const data = JSON.parse(raw);
+            results.push({
+                id: data.id || entry.name.replace(/\.json$/, ""),
+                worktree: data.worktree || data.directory,
+                time: data.time,
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    projectCache = results;
+    return results;
+}
+function pickProjectId(projects, cwd) {
+    const normalized = cwd.replace(/\\/g, "/");
+    let best;
+    for (const project of projects) {
+        if (!project.worktree)
+            continue;
+        const projectPath = project.worktree.replace(/\\/g, "/");
+        if (normalized === projectPath || normalized.startsWith(`${projectPath}/`)) {
+            if (!best || (projectPath.length > (best.worktree?.length || 0))) {
+                best = project;
+            }
+        }
+    }
+    return best?.id;
+}
+async function readLatestSessionForProject(home, projectId) {
+    const now = Date.now();
+    const cached = sessionCache.get(projectId);
+    if (cached && now - cached.scannedAt < SESSION_SCAN_INTERVAL_MS) {
+        return cached.session;
+    }
+    const sessionDir = path.join(home, "storage", "session", projectId);
+    let entries;
+    try {
+        entries = await fsp.readdir(sessionDir, { withFileTypes: true });
+    }
+    catch {
+        sessionCache.set(projectId, { session: undefined, scannedAt: now });
+        return undefined;
+    }
+    let latestPath = null;
+    let latestMtime = 0;
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith("ses_") || !entry.name.endsWith(".json"))
+            continue;
+        const fullPath = path.join(sessionDir, entry.name);
+        try {
+            const stat = await fsp.stat(fullPath);
+            if (stat.mtimeMs > latestMtime) {
+                latestMtime = stat.mtimeMs;
+                latestPath = fullPath;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    if (!latestPath) {
+        sessionCache.set(projectId, { session: undefined, scannedAt: now });
+        return undefined;
+    }
+    try {
+        const raw = await fsp.readFile(latestPath, "utf8");
+        const data = JSON.parse(raw);
+        const session = {
+            id: data.id,
+            title: data.title,
+            directory: data.directory,
+            time: data.time,
+        };
+        sessionCache.set(projectId, { session, scannedAt: now });
+        return session;
+    }
+    catch {
+        sessionCache.set(projectId, { session: undefined, scannedAt: now });
+        return undefined;
+    }
+}
+export async function getOpenCodeSessionForDirectory(cwd, env = process.env) {
+    if (!cwd)
+        return undefined;
+    const home = resolveOpenCodeHome(env);
+    const projects = await listProjectEntries(home);
+    const projectId = pickProjectId(projects, cwd);
+    if (!projectId)
+        return undefined;
+    return await readLatestSessionForProject(home, projectId);
+}

package/dist/scan.js

@@ -6,6 +6,10 @@ import { execFile } from "child_process";
 import { promisify } from "util";
 import { deriveStateWithHold } from "./activity.js";
 import { listRecentSessions, findSessionById, pickSessionForProcess, resolveCodexHome, summarizeTail, updateTail, } from "./codexLogs.js";
+import { getOpenCodeSessions } from "./opencodeApi.js";
+import { ensureOpenCodeServer } from "./opencodeServer.js";
+import { ensureOpenCodeEventStream, getOpenCodeActivityByPid, getOpenCodeActivityBySession, } from "./opencodeEvents.js";
+import { getOpenCodeSessionForDirectory } from "./opencodeStorage.js";
 import { redactText } from "./redact.js";
 const execFileAsync = promisify(execFile);
 const repoCache = new Map();
@@ -27,13 +31,34 @@ function isCodexProcess(cmd, name, matchRe) {
         return true;
     return false;
 }
+function isOpenCodeProcess(cmd, name) {
+    if (!cmd && !name)
+        return false;
+    if (name === "opencode")
+        return true;
+    if (!cmd)
+        return false;
+    const firstToken = cmd.trim().split(/\s+/)[0];
+    const base = path.basename(firstToken);
+    if (base === "opencode")
+        return true;
+    return false;
+}
 function inferKind(cmd) {
     if (cmd.includes(" app-server"))
         return "app-server";
     if (cmd.includes(" exec"))
         return "exec";
-    if (cmd.includes(" codex") || cmd.startsWith("codex"))
+    if (cmd.includes(" codex") || cmd.startsWith("codex") || cmd.includes("/codex"))
         return "tui";
+    if (cmd.includes(" opencode") || cmd.startsWith("opencode") || cmd.includes("/opencode")) {
+        if (cmd.includes(" serve") || cmd.includes("--serve") || cmd.includes(" web")) {
+            return "opencode-server";
+        }
+        if (cmd.includes(" run"))
+            return "opencode-cli";
+        return "opencode-tui";
+    }
     return "unknown";
 }
 function shortenCmd(cmd, max = 120) {
@@ -44,6 +69,22 @@ function shortenCmd(cmd, max = 120) {
 }
 function parseDoingFromCmd(cmd) {
     const parts = cmd.split(/\s+/g);
+    const openIndex = parts.findIndex((part) => part === "opencode" || part.endsWith("/opencode"));
+    if (openIndex !== -1) {
+        const mode = parts[openIndex + 1];
+        if (mode === "serve" || mode === "web")
+            return `opencode ${mode}`;
+        if (mode === "run") {
+            for (let i = openIndex + 2; i < parts.length; i += 1) {
+                const part = parts[i];
+                if (!part || part.startsWith("-"))
+                    continue;
+                return `opencode run: ${part}`;
+            }
+            return "opencode run";
+        }
+        return "opencode";
+    }
     const execIndex = parts.indexOf("exec");
     if (execIndex !== -1) {
         for (let i = execIndex + 1; i < parts.length; i += 1) {
@@ -89,12 +130,43 @@ function extractSessionId(cmd) {
     }
     return undefined;
 }
+function extractOpenCodeSessionId(cmd) {
+    const parts = cmd.split(/\s+/g);
+    const sessionFlag = parts.findIndex((part) => part === "--session" || part === "--session-id" || part === "-s");
+    if (sessionFlag !== -1) {
+        const token = parts[sessionFlag + 1];
+        if (token)
+            return token;
+    }
+    return undefined;
+}
 function normalizeTitle(value) {
     if (!value)
         return undefined;
     return value.replace(/^prompt:\s*/i, "").trim();
 }
-function deriveTitle(doing, repo, pid) {
+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 undefined;
+}
+function coerceNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (!Number.isNaN(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function deriveTitle(doing, repo, pid, kind) {
     if (doing) {
         const trimmed = doing.trim();
         if (trimmed.startsWith("cmd:"))
@@ -110,7 +182,8 @@ function deriveTitle(doing, repo, pid) {
     }
     if (repo)
         return repo;
-    return `codex#${pid}`;
+    const prefix = kind.startsWith("opencode") ? "opencode" : "codex";
+    return `${prefix}#${pid}`;
 }
 function sanitizeSummary(summary) {
     if (!summary)
@@ -146,6 +219,35 @@ async function getCwdsForPids(pids) {
             if (cwd)
                 result.set(pid, cwd);
         }
+        if (result.size > 0) {
+            return result;
+        }
+    }
+    catch {
+        // fall through to lsof
+    }
+    try {
+        const { stdout } = await execFileAsync("lsof", [
+            "-a",
+            "-p",
+            pids.join(","),
+            "-d",
+            "cwd",
+            "-Fn",
+        ]);
+        let currentPid = null;
+        const lines = stdout.split(/\r?\n/).filter(Boolean);
+        for (const line of lines) {
+            if (line.startsWith("p")) {
+                const pid = Number(line.slice(1));
+                currentPid = Number.isNaN(pid) ? null : pid;
+            }
+            else if (line.startsWith("n") && currentPid) {
+                const cwd = line.slice(1).trim();
+                if (cwd)
+                    result.set(currentPid, cwd);
+            }
+        }
     }
     catch {
         return result;
@@ -210,7 +312,11 @@ export async function scanCodexProcesses() {
     }
     const processes = await psList();
     const codexProcs = processes.filter((proc) => isCodexProcess(proc.cmd, proc.name, matchRe));
-    const pids = codexProcs.map((proc) => proc.pid);
+    const codexPidSet = new Set(codexProcs.map((proc) => proc.pid));
+    const opencodeProcs = processes
+        .filter((proc) => isOpenCodeProcess(proc.cmd, proc.name))
+        .filter((proc) => !codexPidSet.has(proc.pid));
+    const pids = Array.from(new Set([...codexProcs, ...opencodeProcs].map((proc) => proc.pid)));
     let usage = {};
     try {
         usage = (await pidusage(pids));
@@ -222,6 +328,31 @@ export async function scanCodexProcesses() {
     const startTimes = await getStartTimesForPids(pids);
     const codexHome = resolveCodexHome();
     const sessions = await listRecentSessions(codexHome);
+    const opencodeHost = process.env.CONSENSUS_OPENCODE_HOST || "127.0.0.1";
+    const opencodePort = Number(process.env.CONSENSUS_OPENCODE_PORT || 4096);
+    const opencodeResult = await getOpenCodeSessions(opencodeHost, opencodePort, {
+        silent: true,
+    });
+    await ensureOpenCodeServer(opencodeHost, opencodePort, opencodeResult);
+    if (opencodeProcs.length) {
+        ensureOpenCodeEventStream(opencodeHost, opencodePort);
+    }
+    const opencodeSessions = opencodeResult.ok ? opencodeResult.sessions : [];
+    const opencodeApiAvailable = opencodeResult.ok;
+    const opencodeSessionsByPid = new Map();
+    const opencodeSessionsByDir = new Map();
+    for (const session of opencodeSessions) {
+        const pid = coerceNumber(session.pid);
+        if (typeof pid === "number") {
+            opencodeSessionsByPid.set(pid, session);
+        }
+        if (typeof session.directory === "string") {
+            opencodeSessionsByDir.set(session.directory, session);
+        }
+        if (typeof session.cwd === "string") {
+            opencodeSessionsByDir.set(session.cwd, session);
+        }
+    }
     const agents = [];
     const seenIds = new Set();
     for (const proc of codexProcs) {
@@ -287,7 +418,7 @@ export async function scanCodexProcesses() {
         const cmdShort = shortenCmd(cmd);
         const kind = inferKind(cmd);
         const startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
-        const computedTitle = title || deriveTitle(doing, repoName, proc.pid);
+        const computedTitle = title || deriveTitle(doing, repoName, proc.pid, kind);
         const safeSummary = sanitizeSummary(summary);
         agents.push({
             id,
@@ -310,6 +441,124 @@ export async function scanCodexProcesses() {
             events,
         });
     }
+    for (const proc of opencodeProcs) {
+        const stats = usage[proc.pid] || {};
+        const cpu = typeof stats.cpu === "number" ? stats.cpu : 0;
+        const mem = typeof stats.memory === "number" ? stats.memory : 0;
+        const elapsed = stats.elapsed;
+        const startMs = typeof elapsed === "number"
+            ? Date.now() - elapsed
+            : startTimes.get(proc.pid);
+        const cmdRaw = proc.cmd || proc.name || "";
+        const sessionByPid = opencodeSessionsByPid.get(proc.pid);
+        const cwdMatch = cwds.get(proc.pid);
+        const sessionByDir = sessionByPid
+            ? undefined
+            : opencodeSessionsByDir.get(cwdMatch || "");
+        const session = sessionByPid || sessionByDir;
+        const storageSession = !session && cwdMatch ? await getOpenCodeSessionForDirectory(cwdMatch) : undefined;
+        const sessionId = session?.id || storageSession?.id || extractOpenCodeSessionId(cmdRaw);
+        const sessionTitle = normalizeTitle(session?.title || session?.name || storageSession?.title);
+        const sessionCwd = session?.cwd || session?.directory || storageSession?.directory;
+        const cwdRaw = sessionCwd || cwds.get(proc.pid);
+        const cwd = redactText(cwdRaw) || cwdRaw;
+        const repoRoot = cwdRaw ? findRepoRoot(cwdRaw) : null;
+        const repoName = repoRoot ? path.basename(repoRoot) : undefined;
+        let lastEventAt = parseTimestamp(session?.lastActivity ||
+            session?.lastActivityAt ||
+            storageSession?.time?.updated ||
+            storageSession?.time?.created ||
+            session?.time?.updated ||
+            session?.time?.created ||
+            session?.updatedAt ||
+            session?.updated ||
+            session?.createdAt ||
+            session?.created);
+        const statusRaw = typeof session?.status === "string" ? session.status : undefined;
+        const status = statusRaw?.toLowerCase();
+        const statusIsError = !!status && /error|failed|failure/.test(status);
+        const statusIsActive = !!status && /running|active|processing/.test(status);
+        const statusIsIdle = !!status && /idle|stopped|paused/.test(status);
+        let hasError = statusIsError;
+        let inFlight = statusIsActive;
+        const model = typeof session?.model === "string" ? session.model : undefined;
+        let doing = sessionTitle;
+        let summary;
+        let events;
+        const eventActivity = getOpenCodeActivityBySession(sessionId) || getOpenCodeActivityByPid(proc.pid);
+        if (eventActivity) {
+            events = eventActivity.events;
+            summary = eventActivity.summary || summary;
+            lastEventAt = eventActivity.lastEventAt || lastEventAt;
+            if (eventActivity.hasError)
+                hasError = true;
+            if (eventActivity.inFlight)
+                inFlight = true;
+            if (eventActivity.summary?.current)
+                doing = eventActivity.summary.current;
+        }
+        if (!doing) {
+            doing =
+                parseDoingFromCmd(proc.cmd || "") || shortenCmd(proc.cmd || proc.name || "");
+        }
+        if (doing)
+            summary = { current: doing };
+        const id = `${proc.pid}`;
+        const cached = activityCache.get(id);
+        const activity = deriveStateWithHold({
+            cpu,
+            hasError,
+            lastEventAt,
+            inFlight,
+            previousActiveAt: cached?.lastActiveAt,
+            now,
+        });
+        let state = activity.state;
+        if (statusIsError)
+            state = "error";
+        else if (statusIsActive)
+            state = "active";
+        else if (statusIsIdle)
+            state = "idle";
+        const hasSignal = statusIsActive ||
+            statusIsIdle ||
+            statusIsError ||
+            typeof lastEventAt === "number" ||
+            !!inFlight;
+        if (!opencodeApiAvailable && !hasSignal)
+            state = "idle";
+        const cpuThreshold = Number(process.env.CONSENSUS_CPU_ACTIVE || 1);
+        if (!hasSignal && cpu <= cpuThreshold) {
+            state = "idle";
+        }
+        activityCache.set(id, { lastActiveAt: state === "active" ? activity.lastActiveAt : undefined, lastSeenAt: now });
+        seenIds.add(id);
+        const cmd = redactText(cmdRaw) || cmdRaw;
+        const cmdShort = shortenCmd(cmd);
+        const kind = inferKind(cmd);
+        const startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
+        const computedTitle = sessionTitle || deriveTitle(doing, repoName, proc.pid, kind);
+        const safeSummary = sanitizeSummary(summary);
+        agents.push({
+            id,
+            pid: proc.pid,
+            startedAt,
+            lastEventAt,
+            title: redactText(computedTitle) || computedTitle,
+            cmd,
+            cmdShort,
+            kind,
+            cpu,
+            mem,
+            state,
+            doing: redactText(doing) || doing,
+            repo: repoName,
+            cwd,
+            model,
+            summary: safeSummary,
+            events,
+        });
+    }
     for (const id of activityCache.keys()) {
         if (!seenIds.has(id)) {
             activityCache.delete(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "consensus-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "private": false,
   "license": "Apache-2.0",
   "repository": {

package/public/app.js

@@ -9,8 +9,10 @@ const panelClose = document.getElementById("panel-close");
 const statusEl = document.getElementById("status");
 const countEl = document.getElementById("count");
 const activeList = document.getElementById("active-list");
+const serverList = document.getElementById("server-list");
 const searchInput = document.getElementById("search");
 const laneTitle = document.querySelector(".lane-title");
+const serverTitle = document.querySelector(".server-title");
 
 const tileW = 96;
 const tileH = 48;
@@ -24,6 +26,11 @@ const statePalette = {
   idle: { top: "#384a57", left: "#2b3943", right: "#25323b", stroke: "#4f6b7a" },
   error: { top: "#82443c", left: "#6d3530", right: "#5a2c28", stroke: "#d1584b" },
 };
+const serverPalette = {
+  active: { top: "#7d6a2b", left: "#665725", right: "#54481f", stroke: "#f5c453" },
+  idle: { top: "#353b42", left: "#272c33", right: "#1f242a", stroke: "#6b7380" },
+  error: statePalette.error,
+};
 const stateOpacity = {
   active: 1,
   idle: 0.35,
@@ -119,12 +126,16 @@ function hashString(input) {
   return Math.abs(hash);
 }
 
-function keyForAgent(agent) {
+function groupKeyForAgent(agent) {
   return agent.repo || agent.cwd || agent.cmd || agent.id;
 }
 
-function assignCoordinate(key) {
-  const hash = hashString(key);
+function keyForAgent(agent) {
+  return `${groupKeyForAgent(agent)}::${agent.id}`;
+}
+
+function assignCoordinate(key, baseKey) {
+  const hash = hashString(baseKey || key);
   const baseX = (hash % 16) - 8;
   const baseY = ((hash >> 4) % 16) - 8;
   const maxRadius = 20;
@@ -152,9 +163,10 @@ function updateLayout(newAgents) {
   const activeKeys = new Set();
   for (const agent of newAgents) {
     const key = keyForAgent(agent);
+    const baseKey = groupKeyForAgent(agent);
     activeKeys.add(key);
     if (!layout.has(key)) {
-      assignCoordinate(key);
+      assignCoordinate(key, baseKey);
     }
   }
 
@@ -170,8 +182,14 @@ function setStatus(text) {
   statusEl.textContent = text;
 }
 
-function setCount(count) {
-  countEl.textContent = `${count} agent${count === 1 ? "" : "s"}`;
+function setCount(agentCount, serverCount) {
+  const agentLabel = `${agentCount} agent${agentCount === 1 ? "" : "s"}`;
+  if (typeof serverCount === "number") {
+    const serverLabel = `${serverCount} server${serverCount === 1 ? "" : "s"}`;
+    countEl.textContent = `${agentLabel} • ${serverLabel}`;
+    return;
+  }
+  countEl.textContent = agentLabel;
 }
 
 function formatBytes(bytes) {
@@ -200,6 +218,26 @@ function escapeHtml(value) {
     .replace(/'/g, "'");
 }
 
+function isServerKind(kind) {
+  return kind === "app-server" || kind === "opencode-server";
+}
+
+function paletteFor(agent) {
+  if (isServerKind(agent.kind)) {
+    return serverPalette[agent.state] || serverPalette.idle;
+  }
+  return statePalette[agent.state] || statePalette.idle;
+}
+
+function accentFor(agent) {
+  return isServerKind(agent.kind) ? "#f5c453" : "#57f2c6";
+}
+
+function accentGlow(agent, alpha) {
+  const tint = isServerKind(agent.kind) ? "245, 196, 83" : "87, 242, 198";
+  return `rgba(${tint}, ${alpha})`;
+}
+
 function labelFor(agent) {
   if (agent.title) return agent.title;
   if (agent.repo) return agent.repo;
@@ -267,10 +305,10 @@ function drawTag(ctx, x, y, text, accent) {
   ctx.restore();
 }
 
-function renderActiveList(items) {
-  if (!activeList) return;
+function renderLaneList(items, container, emptyLabel) {
+  if (!container) return;
   if (!items.length) {
-    activeList.innerHTML = "<div class=\"lane-meta\">No active agents.</div>";
+    container.innerHTML = `<div class="lane-meta">${emptyLabel}</div>`;
     return;
   }
   const sorted = [...items].sort((a, b) => {
@@ -281,7 +319,7 @@ function renderActiveList(items) {
     return b.cpu - a.cpu;
   });
 
-  activeList.innerHTML = sorted
+  container.innerHTML = sorted
     .map((agent) => {
       const doingRaw = agent.summary?.current || agent.doing || agent.cmdShort || "";
       const doing = escapeHtml(truncate(doingRaw, 80));
@@ -299,7 +337,7 @@ function renderActiveList(items) {
     })
     .join("");
 
-  Array.from(activeList.querySelectorAll(".lane-item")).forEach((item) => {
+  Array.from(container.querySelectorAll(".lane-item")).forEach((item) => {
     item.addEventListener("click", () => {
       const id = item.getAttribute("data-id");
       selected = sorted.find((agent) => agent.id === id) || null;
@@ -446,10 +484,14 @@ function draw() {
   const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 
   for (const item of drawList) {
-    const palette = statePalette[item.agent.state] || statePalette.idle;
+    const palette = paletteFor(item.agent);
     const memMB = item.agent.mem / (1024 * 1024);
     const heightBase = Math.min(120, Math.max(18, memMB * 0.4));
     const isActive = item.agent.state === "active";
+    const isServer = isServerKind(item.agent.kind);
+    const accent = accentFor(item.agent);
+    const accentStrong = isServer ? "rgba(245, 196, 83, 0.6)" : "rgba(87, 242, 198, 0.6)";
+    const accentSoft = isServer ? "rgba(245, 196, 83, 0.35)" : "rgba(87, 242, 198, 0.35)";
     const pulse =
       isActive && !reducedMotion
         ? 4 + Math.sin(time / 200) * 3
@@ -490,7 +532,7 @@ function draw() {
         y + tileH * 0.02,
         tileW * 0.92,
         tileH * 0.46,
-        `rgba(87, 242, 198, ${glowAlpha})`,
+        accentGlow(item.agent, glowAlpha),
         null
       );
       drawDiamond(
@@ -499,14 +541,14 @@ function draw() {
         y - height - tileH * 0.18,
         roofSize * 0.82,
         roofSize * 0.42,
-        `rgba(87, 242, 198, ${capAlpha})`,
+        accentGlow(item.agent, capAlpha),
         null
       );
       ctx.restore();
     }
 
     if (selected && selected.id === item.agent.id) {
-      drawDiamond(ctx, x, y, tileW + 10, tileH + 6, "rgba(0,0,0,0)", "#57f2c6");
+      drawDiamond(ctx, x, y, tileW + 10, tileH + 6, "rgba(0,0,0,0)", accent);
     }
 
     ctx.fillStyle = "rgba(10, 12, 15, 0.6)";
@@ -519,15 +561,21 @@ function draw() {
     const showActiveTag = topActiveIds.has(item.agent.id);
     if (isHovered || isSelected) {
       const label = truncate(labelFor(item.agent), 20);
-      drawTag(ctx, x, y - height - tileH * 0.6, label, "rgba(87, 242, 198, 0.6)");
+      drawTag(ctx, x, y - height - tileH * 0.6, label, accentStrong);
       const doing = truncate(item.agent.summary?.current || item.agent.doing || "", 36);
-      drawTag(ctx, x, y - height - tileH * 0.9, doing, "rgba(87, 242, 198, 0.35)");
+      drawTag(ctx, x, y - height - tileH * 0.9, doing, accentSoft);
+      if (isServer) {
+        drawTag(ctx, x, y + tileH * 0.2, "server", "rgba(79, 107, 122, 0.6)");
+      }
     } else if (showActiveTag) {
       const doing = truncate(
         item.agent.summary?.current || item.agent.doing || labelFor(item.agent),
         32
       );
-      drawTag(ctx, x, y - height - tileH * 0.7, doing, "rgba(87, 242, 198, 0.35)");
+      drawTag(ctx, x, y - height - tileH * 0.7, doing, accentSoft);
+      if (isServer) {
+        drawTag(ctx, x, y + tileH * 0.2, "server", "rgba(79, 107, 122, 0.6)");
+      }
     }
 
     hitList.push({
@@ -680,7 +728,9 @@ function connect() {
 
 function applySnapshot(payload) {
   agents = payload.agents || [];
-  setCount(agents.length);
+  const serverAgents = agents.filter((agent) => isServerKind(agent.kind));
+  const agentNodes = agents.filter((agent) => !isServerKind(agent.kind));
+  setCount(agentNodes.length, serverAgents.length);
   const query = searchQuery.trim().toLowerCase();
   searchMatches = new Set(
     query ? agents.filter((agent) => matchesQuery(agent, query)).map((agent) => agent.id) : []
@@ -689,12 +739,19 @@ function applySnapshot(payload) {
     ? agents.filter((agent) => searchMatches.has(agent.id))
     : agents;
   const listAgents = query
-    ? visibleAgents
-    : visibleAgents.filter((agent) => agent.state !== "idle");
+    ? visibleAgents.filter((agent) => !isServerKind(agent.kind))
+    : visibleAgents.filter((agent) => agent.state !== "idle" && !isServerKind(agent.kind));
+  const listServers = query
+    ? visibleAgents.filter((agent) => isServerKind(agent.kind))
+    : visibleAgents.filter((agent) => isServerKind(agent.kind));
   if (laneTitle) {
     laneTitle.textContent = query ? "search results" : "active agents";
   }
-  renderActiveList(listAgents);
+  if (serverTitle) {
+    serverTitle.textContent = query ? "server results" : "servers";
+  }
+  renderLaneList(listAgents, activeList, "No active agents.");
+  renderLaneList(listServers, serverList, "No servers detected.");
   if (selected) {
     selected = agents.find((agent) => agent.id === selected.id) || selected;
     renderPanel(selected);

package/public/index.html

@@ -41,6 +41,9 @@
           aria-label="Search metadata"
         />
         <div id="active-list"></div>
+        <div class="lane-divider" aria-hidden="true"></div>
+        <div class="lane-title server-title">servers</div>
+        <div id="server-list"></div>
       </div>
       <div id="tooltip" class="hidden"></div>
       <aside id="panel" class="collapsed" aria-label="Agent details">

package/public/style.css

@@ -282,6 +282,18 @@ body {
   gap: 8px;
 }
 
+#server-list {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.lane-divider {
+  height: 1px;
+  margin: 12px 0;
+  background: rgba(62, 78, 89, 0.6);
+}
+
 .lane-item {
   display: flex;
   align-items: flex-start;