consensus-cli 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -5,6 +5,17 @@ This project follows Semantic Versioning.
 
 ## Unreleased
 
+## 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

@@ -64,8 +64,9 @@ consensus dev server running on http://127.0.0.1:8787
 - `CONSENSUS_CODEX_HOME`: override Codex home (default `~/.codex`).
 - `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/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/scan.js

@@ -4,11 +4,12 @@ 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 { 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 +17,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 "))
@@ -70,6 +73,22 @@ 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 normalizeTitle(value) {
     if (!value)
         return undefined;
@@ -133,6 +152,32 @@ async function getCwdsForPids(pids) {
     }
     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;
+    }
+    return result;
+}
 function findRepoRoot(cwd) {
     if (repoCache.has(cwd))
         return repoCache.get(cwd) || null;
@@ -152,6 +197,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) {
@@ -173,16 +219,24 @@ export async function scanCodexProcesses() {
         usage = {};
     }
     const cwds = await getCwdsForPids(pids);
+    const startTimes = await getStartTimesForPids(pids);
     const codexHome = resolveCodexHome();
     const sessions = await listRecentSessions(codexHome);
     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 +244,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 +256,7 @@ export async function scanCodexProcesses() {
                 title = normalizeTitle(tailSummary.title);
                 summary = tailSummary.summary;
                 lastEventAt = tailSummary.lastEventAt;
+                inFlight = !!tailSummary.inFlight;
             }
         }
         if (!doing) {
@@ -214,12 +270,22 @@ 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 safeSummary = sanitizeSummary(summary);
@@ -244,7 +310,12 @@ export async function scanCodexProcesses() {
             events,
         });
     }
-    return { ts: Date.now(), agents };
+    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.2",
   "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",

package/public/app.js

@@ -49,6 +49,53 @@ let searchMatches = new Set();
 const layout = new Map();
 const occupied = new Map();
 
+function ensureSelectedVisible(agent) {
+  if (!agent || !panel.classList.contains("open")) return;
+  if (view.dragging) return;
+  const panelRect = panel.getBoundingClientRect();
+  if (panelRect.width >= window.innerWidth * 0.8) return;
+  const key = keyForAgent(agent);
+  const coord = layout.get(key);
+  if (!coord) return;
+
+  const screen = isoToScreen(coord.x, coord.y, tileW, tileH);
+  const memMB = (agent.mem || 0) / (1024 * 1024);
+  const heightBase = Math.min(120, Math.max(18, memMB * 0.4));
+  const idleScale = agent.state === "idle" ? 0.6 : 1;
+  const height = heightBase * idleScale;
+
+  const targetX = view.x + screen.x * view.scale;
+  const targetY = view.y + screen.y * view.scale;
+  const halfW = (tileW / 2) * view.scale;
+  const halfH = (tileH / 2) * view.scale;
+  const padding = 36;
+  const viewportWidth = window.innerWidth - panelRect.width;
+  const viewportHeight = window.innerHeight;
+
+  const left = targetX - halfW;
+  const right = targetX + halfW;
+  const top = targetY - (height + tileH * 0.6) * view.scale;
+  const bottom = targetY + (halfH + tileH * 0.6) * view.scale;
+
+  let dx = 0;
+  let dy = 0;
+  if (right > viewportWidth - padding) {
+    dx = viewportWidth - padding - right;
+  } else if (left < padding) {
+    dx = padding - left;
+  }
+  if (top < padding) {
+    dy = padding - top;
+  } else if (bottom > viewportHeight - padding) {
+    dy = viewportHeight - padding - bottom;
+  }
+
+  if (dx !== 0 || dy !== 0) {
+    view.x += dx;
+    view.y += dy;
+  }
+}
+
 function resize() {
   deviceScale = window.devicePixelRatio || 1;
   canvas.width = window.innerWidth * deviceScale;
@@ -369,13 +416,16 @@ function draw() {
     ctx.fillStyle = "rgba(228, 230, 235, 0.6)";
     ctx.font = "16px Space Grotesk";
     ctx.textAlign = "center";
-    ctx.fillText("No codex processes found", 0, 0);
-    ctx.restore();
-    requestAnimationFrame(draw);
-    return;
+  ctx.fillText("No codex processes found", 0, 0);
+  ctx.restore();
+  requestAnimationFrame(draw);
+  return;
   }
 
   updateLayout(agents);
+  if (selected) {
+    ensureSelectedVisible(selected);
+  }
 
   const drawList = agents
     .map((agent) => {
@@ -399,10 +449,15 @@ function draw() {
     const palette = statePalette[item.agent.state] || statePalette.idle;
     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 pulse =
-      item.agent.state === "active" && !reducedMotion
+      isActive && !reducedMotion
         ? 4 + Math.sin(time / 200) * 3
         : 0;
+    const pulsePhase =
+      isActive && !reducedMotion
+        ? (Math.sin(time / 240) + 1) / 2
+        : 0;
     const idleScale = item.agent.state === "idle" ? 0.6 : 1;
     const height = heightBase * idleScale + pulse;
 
@@ -425,6 +480,31 @@ function draw() {
       null
     );
 
+    if (isActive) {
+      const glowAlpha = 0.12 + pulsePhase * 0.22;
+      const capAlpha = 0.16 + pulsePhase * 0.28;
+      ctx.save();
+      drawDiamond(
+        ctx,
+        x,
+        y + tileH * 0.02,
+        tileW * 0.92,
+        tileH * 0.46,
+        `rgba(87, 242, 198, ${glowAlpha})`,
+        null
+      );
+      drawDiamond(
+        ctx,
+        x,
+        y - height - tileH * 0.18,
+        roofSize * 0.82,
+        roofSize * 0.42,
+        `rgba(87, 242, 198, ${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");
     }

package/public/style.css

@@ -320,11 +320,13 @@ body {
   margin-top: 6px;
   background: var(--idle);
   box-shadow: 0 0 10px transparent;
+  transform-origin: center;
 }
 
 .lane-pill.active {
   background: var(--active);
   box-shadow: 0 0 12px rgba(81, 195, 165, 0.5);
+  animation: lanePulse 1.3s ease-in-out infinite;
 }
 
 .lane-pill.error {
@@ -332,6 +334,21 @@ body {
   box-shadow: 0 0 12px rgba(209, 88, 75, 0.5);
 }
 
+@keyframes lanePulse {
+  0% {
+    transform: scale(1);
+    box-shadow: 0 0 10px rgba(81, 195, 165, 0.35);
+  }
+  50% {
+    transform: scale(1.35);
+    box-shadow: 0 0 16px rgba(81, 195, 165, 0.6);
+  }
+  100% {
+    transform: scale(1);
+    box-shadow: 0 0 10px rgba(81, 195, 165, 0.35);
+  }
+}
+
 .lane-copy {
   display: flex;
   flex-direction: column;