consensus-cli 0.1.0 → 0.1.4

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

@@ -4,11 +4,16 @@ import fs from "fs";
 import path from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { deriveState } from "./activity.js";
-import { listRecentSessions, pickSessionForProcess, resolveCodexHome, summarizeTail, updateTail, } from "./codexLogs.js";
+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();
+const activityCache = new Map();
 function isCodexProcess(cmd, name, matchRe) {
     if (!cmd && !name)
         return false;
@@ -16,6 +21,8 @@ function isCodexProcess(cmd, name, matchRe) {
         return matchRe.test(cmd || "") || matchRe.test(name || "");
     }
     const cmdLine = cmd || "";
+    if (cmdLine.includes("/codex/vendor/"))
+        return false;
     if (name === "codex")
         return true;
     if (cmdLine === "codex" || cmdLine.startsWith("codex "))
@@ -24,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) {
@@ -41,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) {
@@ -70,12 +114,59 @@ function parseDoingFromCmd(cmd) {
         return "codex";
     return undefined;
 }
+function extractSessionId(cmd) {
+    const parts = cmd.split(/\s+/g);
+    const resumeIndex = parts.indexOf("resume");
+    if (resumeIndex !== -1) {
+        const token = parts[resumeIndex + 1];
+        if (token && /^[0-9a-fA-F-]{16,}$/.test(token))
+            return token;
+    }
+    const sessionFlag = parts.findIndex((part) => part === "--session" || part === "--session-id");
+    if (sessionFlag !== -1) {
+        const token = parts[sessionFlag + 1];
+        if (token && /^[0-9a-fA-F-]{16,}$/.test(token))
+            return token;
+    }
+    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:"))
@@ -91,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)
@@ -127,6 +219,61 @@ 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;
+    }
+    return result;
+}
+async function getStartTimesForPids(pids) {
+    const result = new Map();
+    if (pids.length === 0)
+        return result;
+    if (process.platform === "win32")
+        return result;
+    try {
+        const { stdout } = await execFileAsync("ps", ["-o", "pid=,lstart=", "-p", pids.join(",")]);
+        const lines = stdout.split(/\r?\n/).filter(Boolean);
+        for (const line of lines) {
+            const match = line.match(/^\s*(\d+)\s+(.*)$/);
+            if (!match)
+                continue;
+            const pid = Number(match[1]);
+            const dateStr = match[2].trim();
+            const parsed = Date.parse(dateStr);
+            if (!Number.isNaN(parsed)) {
+                result.set(pid, parsed);
+            }
+        }
     }
     catch {
         return result;
@@ -152,6 +299,7 @@ function findRepoRoot(cwd) {
     return null;
 }
 export async function scanCodexProcesses() {
+    const now = Date.now();
     const matchEnv = process.env.CONSENSUS_PROCESS_MATCH;
     let matchRe;
     if (matchEnv) {
@@ -164,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));
@@ -173,16 +325,49 @@ export async function scanCodexProcesses() {
         usage = {};
     }
     const cwds = await getCwdsForPids(pids);
+    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) {
         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 : undefined;
-        const session = pickSessionForProcess(sessions, startMs);
+        const startMs = typeof elapsed === "number"
+            ? Date.now() - elapsed
+            : startTimes.get(proc.pid);
+        const cmdRaw = proc.cmd || proc.name || "";
+        const sessionId = extractSessionId(cmdRaw);
+        const session = (sessionId && sessions.find((item) => item.path.includes(sessionId))) ||
+            (sessionId ? await findSessionById(codexHome, sessionId) : undefined) ||
+            pickSessionForProcess(sessions, startMs);
         let doing;
         let events;
         let model;
@@ -190,6 +375,7 @@ export async function scanCodexProcesses() {
         let title;
         let summary;
         let lastEventAt;
+        let inFlight = false;
         if (session) {
             const tail = await updateTail(session.path);
             if (tail) {
@@ -201,6 +387,7 @@ export async function scanCodexProcesses() {
                 title = normalizeTitle(tailSummary.title);
                 summary = tailSummary.summary;
                 lastEventAt = tailSummary.lastEventAt;
+                inFlight = !!tailSummary.inFlight;
             }
         }
         if (!doing) {
@@ -214,14 +401,24 @@ export async function scanCodexProcesses() {
         const cwd = redactText(cwdRaw) || cwdRaw;
         const repoRoot = cwdRaw ? findRepoRoot(cwdRaw) : null;
         const repoName = repoRoot ? path.basename(repoRoot) : undefined;
-        const state = deriveState({ cpu, hasError, lastEventAt });
-        const cmdRaw = proc.cmd || proc.name || "";
+        const id = `${proc.pid}`;
+        const cached = activityCache.get(id);
+        const activity = deriveStateWithHold({
+            cpu,
+            hasError,
+            lastEventAt,
+            inFlight,
+            previousActiveAt: cached?.lastActiveAt,
+            now,
+        });
+        const state = activity.state;
+        activityCache.set(id, { lastActiveAt: activity.lastActiveAt, lastSeenAt: now });
+        seenIds.add(id);
         const cmd = redactText(cmdRaw) || cmdRaw;
         const cmdShort = shortenCmd(cmd);
         const kind = inferKind(cmd);
-        const id = `${proc.pid}`;
         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,
@@ -244,7 +441,130 @@ export async function scanCodexProcesses() {
             events,
         });
     }
-    return { ts: Date.now(), agents };
+    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);
+        }
+    }
+    return { ts: now, agents };
 }
 const isDirectRun = process.argv[1] && process.argv[1].endsWith("scan.js");
 if (isDirectRun) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "consensus-cli",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "private": false,
   "license": "Apache-2.0",
   "repository": {
@@ -14,7 +14,8 @@
   "type": "module",
   "main": "dist/server.js",
   "bin": {
-    "consensus": "dist/cli.js"
+    "consensus": "dist/cli.js",
+    "consensus-cli": "dist/cli.js"
   },
   "files": [
     "dist",