consensus-cli 0.1.4 → 0.1.5

package/CHANGELOG.md

@@ -5,6 +5,12 @@ This project follows Semantic Versioning.
 
 ## Unreleased
 
+## 0.1.5 - 2026-01-25
+- Add Claude Code process detection with prompt/resume parsing.
+- Apply CLI-specific palettes (Codex/OpenCode/Claude Code) across tiles and lane items.
+- Add Claude CLI parsing unit tests.
+- Update README with Claude Code support.
+
 ## 0.1.4 - 2026-01-24
 - Fix OpenCode event tracking build error (pid activity typing).
 

package/README.md

@@ -1,12 +1,16 @@
 # consensus-cli
 
-Live isometric atlas for Codex CLI processes, rendered in a local browser.
+[![npm](https://img.shields.io/npm/v/consensus-cli.svg?color=0f766e)](https://www.npmjs.com/package/consensus-cli)
+[![GitHub release](https://img.shields.io/github/v/release/integrate-your-mind/consensus-cli?display_name=tag&color=2563eb)](https://github.com/integrate-your-mind/consensus-cli/releases)
+[![License](https://img.shields.io/npm/l/consensus-cli.svg?color=6b7280)](LICENSE)
+
+Live isometric atlas for Codex, OpenCode, and Claude Code sessions, rendered in a local browser.
 
 ## Status
 Beta. Local-only, no hosted service.
 
 ## Who it's for
-Developers running multiple Codex sessions who want a visual, at-a-glance view of activity.
+Developers running multiple Codex, OpenCode, or Claude Code sessions who want a visual, at-a-glance view of activity.
 
 ## Core use cases
 - Track which agents are active right now.
@@ -15,7 +19,7 @@ Developers running multiple Codex sessions who want a visual, at-a-glance view o
 
 ## Scope (non-goals)
 - Does not start, stop, or manage processes.
-- Does not connect to remote Codex instances.
+- Does not connect to remote Codex, OpenCode, or Claude Code instances.
 - No authentication or multi-user access.
 
 ## Quickstart
@@ -27,6 +31,8 @@ npm run dev
 The server prints the local URL (default `http://127.0.0.1:8787`).
 Consensus reads local Codex CLI sessions and does not require API keys.
 You just need Codex CLI installed and signed in (Pro subscription or team plan).
+If OpenCode is installed, Consensus will auto-start its local server.
+If Claude Code is installed, it will appear automatically (run `claude` once to sign in).
 
 ## Run via npx
 ```bash
@@ -39,17 +45,19 @@ consensus dev server running on http://127.0.0.1:8787
 ```
 
 ## What you get
-- One tile per running `codex` process.
+- One tile per running `codex`, `opencode`, or `claude` process.
 - Activity state (active/idle/error) from CPU and recent events.
-- Best-effort "doing" summary from Codex session JSONL.
+- Best-effort "doing" summary from Codex session JSONL, OpenCode events, or Claude CLI flags.
 - Click a tile for details and recent events.
-- Active lane that highlights what is working right now.
+- Active lane for agents plus a dedicated lane for servers.
 
 ## How it works
-1) Scan OS process list for Codex.
-2) Resolve recent session JSONL under `CODEX_HOME/sessions/`.
-3) Poll and push snapshots over WebSocket.
-4) Render tiles on a canvas with isometric projection.
+1) Scan OS process list for Codex + OpenCode + Claude Code.
+2) Resolve Codex session JSONL under `CODEX_HOME/sessions/`.
+3) Query the OpenCode local server API and event stream (with storage fallback).
+4) Read Claude Code CLI flags to infer current work.
+5) Poll and push snapshots over WebSocket.
+6) Render tiles on a canvas with isometric projection.
 
 ## Install options
 - Local dev: `npm install` + `npm run dev`

package/dist/claudeCli.js

@@ -0,0 +1,125 @@
+import { deriveStateWithHold } from "./activity.js";
+const CLAUDE_BINARIES = new Set(["claude", "claude.exe"]);
+export function splitArgs(command) {
+    if (!command)
+        return [];
+    const args = [];
+    const regex = /"([^"]*)"|'([^']*)'|\S+/g;
+    let match;
+    while ((match = regex.exec(command)) !== null) {
+        const token = match[1] ?? match[2] ?? match[0];
+        if (token)
+            args.push(token);
+    }
+    return args;
+}
+function findClaudeIndex(parts) {
+    for (let i = 0; i < parts.length; i += 1) {
+        const base = parts[i] ? parts[i].split(/[/\\]/).pop() || "" : "";
+        if (CLAUDE_BINARIES.has(base))
+            return i;
+    }
+    return -1;
+}
+function readFlagValue(parts, flag) {
+    const idx = parts.indexOf(flag);
+    if (idx === -1)
+        return undefined;
+    const value = parts[idx + 1];
+    if (!value || value.startsWith("-"))
+        return undefined;
+    return value;
+}
+function findPrompt(parts, startIndex) {
+    for (let i = startIndex; i < parts.length; i += 1) {
+        const part = parts[i];
+        if (!part)
+            continue;
+        if (part === "-p" || part === "--print") {
+            const next = parts[i + 1];
+            if (next && !next.startsWith("-"))
+                return next;
+        }
+        if (part.startsWith("-")) {
+            const skipFlags = new Set([
+                "--output-format",
+                "--input-format",
+                "--model",
+                "--max-turns",
+                "--max-budget-usd",
+                "--tools",
+                "--allowedTools",
+                "--disallowedTools",
+                "--resume",
+                "-r",
+                "--session-id",
+                "--continue",
+                "-c",
+            ]);
+            if (skipFlags.has(part)) {
+                i += 1;
+            }
+            continue;
+        }
+        return part;
+    }
+    return undefined;
+}
+export function parseClaudeCommand(command) {
+    const parts = splitArgs(command);
+    const claudeIndex = findClaudeIndex(parts);
+    if (claudeIndex === -1)
+        return null;
+    const hasPrint = parts.includes("-p") || parts.includes("--print");
+    const continued = parts.includes("--continue") || parts.includes("-c");
+    const resume = readFlagValue(parts, "--resume") || readFlagValue(parts, "-r");
+    const model = readFlagValue(parts, "--model");
+    const prompt = findPrompt(parts, claudeIndex + 1);
+    return {
+        kind: hasPrint ? "claude-cli" : "claude-tui",
+        prompt,
+        resume,
+        continued,
+        model,
+        print: hasPrint,
+    };
+}
+export function summarizeClaudeCommand(command) {
+    const info = parseClaudeCommand(command);
+    if (!info)
+        return null;
+    if (info.prompt) {
+        return { ...info, doing: `prompt: ${info.prompt}` };
+    }
+    if (info.resume) {
+        return { ...info, doing: `resume: ${info.resume}` };
+    }
+    if (info.continued) {
+        return { ...info, doing: "continue" };
+    }
+    if (info.print) {
+        return { ...info, doing: "claude print" };
+    }
+    return { ...info, doing: "claude" };
+}
+export function deriveClaudeState(input) {
+    const info = input.info ?? null;
+    const baseThreshold = input.cpuThreshold ??
+        Number(process.env.CONSENSUS_CLAUDE_CPU_ACTIVE || process.env.CONSENSUS_CPU_ACTIVE || 1);
+    const hasWork = !!info?.prompt || !!info?.resume || !!info?.continued;
+    const isTui = info?.kind === "claude-tui";
+    const effectiveThreshold = isTui && !hasWork ? baseThreshold * 3 : baseThreshold;
+    const result = deriveStateWithHold({
+        cpu: input.cpu,
+        hasError: false,
+        lastEventAt: undefined,
+        inFlight: hasWork,
+        previousActiveAt: input.previousActiveAt,
+        now: input.now,
+        cpuThreshold: effectiveThreshold,
+    });
+    if (!hasWork && input.cpu <= effectiveThreshold) {
+        return { state: "idle", lastActiveAt: undefined };
+    }
+    return result;
+}

package/dist/codexLogs.js

@@ -266,6 +266,8 @@ export async function updateTail(sessionPath) {
             partial: "",
             events: [],
         };
+    const prevMtime = state.lastMtimeMs;
+    state.lastMtimeMs = stat.mtimeMs;
     if (stat.size < state.offset) {
         state.offset = 0;
         state.partial = "";
@@ -313,15 +315,15 @@ export async function updateTail(sessionPath) {
     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) {
+    const processLine = (line) => {
         if (!line.trim())
-            continue;
+            return false;
         let ev;
         try {
             ev = JSON.parse(line);
         }
         catch {
-            continue;
+            return false;
         }
         const ts = getEventTimestamp(ev);
         const { summary, kind, isError, model, type } = summarizeEvent(ev);
@@ -357,20 +359,39 @@ export async function updateTail(sessionPath) {
             if (state.events.length > MAX_EVENTS) {
                 state.events = state.events.slice(-MAX_EVENTS);
             }
+            return true;
         }
-        else {
-            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
-            if (isError) {
-                state.lastError = {
-                    ts,
-                    type: typeof type === "string" ? type : "event",
-                    summary: "error",
-                    isError,
-                };
-            }
+        state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+        if (isError) {
+            state.lastError = {
+                ts,
+                type: typeof type === "string" ? type : "event",
+                summary: "error",
+                isError,
+            };
+            return true;
+        }
+        return true;
+    };
+    let parsedAny = false;
+    for (const line of lines) {
+        if (processLine(line))
+            parsedAny = true;
+    }
+    const candidate = state.partial.trim();
+    if (candidate.startsWith("{") && candidate.endsWith("}")) {
+        if (processLine(candidate)) {
+            parsedAny = true;
+            state.partial = "";
         }
     }
     state.offset = stat.size;
+    if (!state.lastEventAt && typeof stat.mtimeMs === "number") {
+        state.lastEventAt = stat.mtimeMs;
+    }
+    else if (stat.size > prevOffset && prevMtime && prevMtime !== stat.mtimeMs) {
+        state.lastEventAt = Math.max(state.lastEventAt || 0, stat.mtimeMs);
+    }
     tailStates.set(sessionPath, state);
     return state;
 }

package/dist/opencodeEvents.js

@@ -120,7 +120,7 @@ function summarizeEvent(raw) {
         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 };
+        return { summary, kind: "edit", isError, type, inFlight };
     }
     const tool = raw?.tool ||
         raw?.tool_name ||
@@ -139,7 +139,7 @@ function summarizeEvent(raw) {
         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 };
+        return { summary, kind: "prompt", isError, type, inFlight };
     }
     const messageText = extractText(raw?.message) ||
         extractText(raw?.content) ||
@@ -149,13 +149,13 @@ function summarizeEvent(raw) {
         const trimmed = messageText.replace(/\s+/g, " ").trim();
         const snippet = trimmed.slice(0, 80);
         const summary = redactText(snippet) || snippet;
-        return { summary, kind: "message", isError, type };
+        return { summary, kind: "message", isError, type, inFlight };
     }
     if (type && type !== "event") {
         const summary = redactText(`event: ${type}`) || `event: ${type}`;
-        return { summary, kind: "other", isError, type };
+        return { summary, kind: "other", isError, type, inFlight };
     }
-    return { kind: "other", isError, type };
+    return { kind: "other", isError, type, inFlight };
 }
 function ensureActivity(key, map, now) {
     const existing = map.get(key);
@@ -209,28 +209,57 @@ function handleRawEvent(raw) {
     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 entry = summary
+        ? {
+            ts,
+            type: typeof type === "string" ? type : "event",
+            summary,
+            isError,
+        }
+        : null;
     const now = nowMs();
     if (sessionId) {
         const state = ensureActivity(sessionId, sessionActivity, now);
-        recordEvent(state, entry, kind);
+        if (entry) {
+            recordEvent(state, entry, kind);
+        }
+        else {
+            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+            if (isError) {
+                state.lastError = {
+                    ts,
+                    type: typeof type === "string" ? type : "event",
+                    summary: "error",
+                    isError,
+                };
+            }
+        }
         if (typeof inFlight === "boolean")
             state.inFlight = inFlight;
     }
     if (typeof pid === "number") {
         const state = ensureActivity(pid, pidActivity, now);
-        recordEvent(state, entry, kind);
+        if (entry) {
+            recordEvent(state, entry, kind);
+        }
+        else {
+            state.lastEventAt = Math.max(state.lastEventAt || 0, ts);
+            if (isError) {
+                state.lastError = {
+                    ts,
+                    type: typeof type === "string" ? type : "event",
+                    summary: "error",
+                    isError,
+                };
+            }
+        }
         if (typeof inFlight === "boolean")
             state.inFlight = inFlight;
     }
 }
+export function ingestOpenCodeEvent(raw) {
+    handleRawEvent(raw);
+}
 function pruneStale() {
     const cutoff = nowMs() - STALE_TTL_MS;
     for (const [key, state] of sessionActivity.entries()) {

package/dist/opencodeState.js

@@ -0,0 +1,36 @@
+import { deriveStateWithHold } from "./activity.js";
+export function deriveOpenCodeState(input) {
+    const status = input.status?.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);
+    const activity = deriveStateWithHold({
+        cpu: input.cpu,
+        hasError: input.hasError,
+        lastEventAt: input.lastEventAt,
+        inFlight: input.inFlight,
+        previousActiveAt: input.previousActiveAt,
+        now: input.now,
+        cpuThreshold: input.cpuThreshold,
+        eventWindowMs: input.eventWindowMs,
+        holdMs: input.holdMs,
+    });
+    let state = activity.state;
+    if (statusIsError) {
+        state = "error";
+    }
+    else if (statusIsIdle) {
+        state = "idle";
+    }
+    else if (statusIsActive && state !== "active") {
+        state = "idle";
+    }
+    const cpuThreshold = input.cpuThreshold ?? Number(process.env.CONSENSUS_CPU_ACTIVE || 1);
+    if (input.isServer) {
+        state = input.cpu > cpuThreshold ? "active" : "idle";
+    }
+    if (state === "idle") {
+        return { state, lastActiveAt: undefined };
+    }
+    return { state, lastActiveAt: activity.lastActiveAt };
+}

package/dist/scan.js

@@ -10,6 +10,8 @@ import { getOpenCodeSessions } from "./opencodeApi.js";
 import { ensureOpenCodeServer } from "./opencodeServer.js";
 import { ensureOpenCodeEventStream, getOpenCodeActivityByPid, getOpenCodeActivityBySession, } from "./opencodeEvents.js";
 import { getOpenCodeSessionForDirectory } from "./opencodeStorage.js";
+import { deriveOpenCodeState } from "./opencodeState.js";
+import { deriveClaudeState, summarizeClaudeCommand } from "./claudeCli.js";
 import { redactText } from "./redact.js";
 const execFileAsync = promisify(execFile);
 const repoCache = new Map();
@@ -44,6 +46,19 @@ function isOpenCodeProcess(cmd, name) {
         return true;
     return false;
 }
+function isClaudeProcess(cmd, name) {
+    if (!cmd && !name)
+        return false;
+    if (name === "claude")
+        return true;
+    if (!cmd)
+        return false;
+    const firstToken = cmd.trim().split(/\s+/)[0];
+    const base = path.basename(firstToken);
+    if (base === "claude" || base === "claude.exe")
+        return true;
+    return false;
+}
 function inferKind(cmd) {
     if (cmd.includes(" app-server"))
         return "app-server";
@@ -59,6 +74,9 @@ function inferKind(cmd) {
             return "opencode-cli";
         return "opencode-tui";
     }
+    const claudeInfo = summarizeClaudeCommand(cmd);
+    if (claudeInfo)
+        return claudeInfo.kind;
     return "unknown";
 }
 function shortenCmd(cmd, max = 120) {
@@ -69,6 +87,9 @@ function shortenCmd(cmd, max = 120) {
 }
 function parseDoingFromCmd(cmd) {
     const parts = cmd.split(/\s+/g);
+    const claudeInfo = summarizeClaudeCommand(cmd);
+    if (claudeInfo?.doing)
+        return claudeInfo.doing;
     const openIndex = parts.findIndex((part) => part === "opencode" || part.endsWith("/opencode"));
     if (openIndex !== -1) {
         const mode = parts[openIndex + 1];
@@ -182,7 +203,11 @@ function deriveTitle(doing, repo, pid, kind) {
     }
     if (repo)
         return repo;
-    const prefix = kind.startsWith("opencode") ? "opencode" : "codex";
+    const prefix = kind.startsWith("opencode")
+        ? "opencode"
+        : kind.startsWith("claude")
+            ? "claude"
+            : "codex";
     return `${prefix}#${pid}`;
 }
 function sanitizeSummary(summary) {
@@ -316,7 +341,11 @@ export async function scanCodexProcesses() {
     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)));
+    const opencodePidSet = new Set(opencodeProcs.map((proc) => proc.pid));
+    const claudeProcs = processes
+        .filter((proc) => isClaudeProcess(proc.cmd, proc.name))
+        .filter((proc) => !codexPidSet.has(proc.pid) && !opencodePidSet.has(proc.pid));
+    const pids = Array.from(new Set([...codexProcs, ...opencodeProcs, ...claudeProcs].map((proc) => proc.pid)));
     let usage = {};
     try {
         usage = (await pidusage(pids));
@@ -332,6 +361,7 @@ export async function scanCodexProcesses() {
     const opencodePort = Number(process.env.CONSENSUS_OPENCODE_PORT || 4096);
     const opencodeResult = await getOpenCodeSessions(opencodeHost, opencodePort, {
         silent: true,
+        timeoutMs: Number(process.env.CONSENSUS_OPENCODE_TIMEOUT_MS || 1000),
     });
     await ensureOpenCodeServer(opencodeHost, opencodePort, opencodeResult);
     if (opencodeProcs.length) {
@@ -441,6 +471,9 @@ export async function scanCodexProcesses() {
             events,
         });
     }
+    const opencodeEventWindowMs = Number(process.env.CONSENSUS_OPENCODE_EVENT_ACTIVE_MS || 90000);
+    const opencodeHoldMs = Number(process.env.CONSENSUS_OPENCODE_ACTIVE_HOLD_MS || 120000);
+    const cpuThreshold = Number(process.env.CONSENSUS_CPU_ACTIVE || 1);
     for (const proc of opencodeProcs) {
         const stats = usage[proc.pid] || {};
         const cpu = typeof stats.cpu === "number" ? stats.cpu : 0;
@@ -464,7 +497,7 @@ export async function scanCodexProcesses() {
         const cwd = redactText(cwdRaw) || cwdRaw;
         const repoRoot = cwdRaw ? findRepoRoot(cwdRaw) : null;
         const repoName = repoRoot ? path.basename(repoRoot) : undefined;
-        let lastEventAt = parseTimestamp(session?.lastActivity ||
+        const lastActivityAt = parseTimestamp(session?.lastActivity ||
             session?.lastActivityAt ||
             storageSession?.time?.updated ||
             storageSession?.time?.created ||
@@ -477,15 +510,15 @@ export async function scanCodexProcesses() {
         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);
+        let lastEventAt = eventActivity?.lastEventAt;
+        let inFlight = eventActivity?.inFlight;
         if (eventActivity) {
             events = eventActivity.events;
             summary = eventActivity.summary || summary;
@@ -497,6 +530,9 @@ export async function scanCodexProcesses() {
             if (eventActivity.summary?.current)
                 doing = eventActivity.summary.current;
         }
+        if (!lastEventAt && statusIsIdle) {
+            lastEventAt = undefined;
+        }
         if (!doing) {
             doing =
                 parseDoingFromCmd(proc.cmd || "") || shortenCmd(proc.cmd || proc.name || "");
@@ -505,37 +541,34 @@ export async function scanCodexProcesses() {
             summary = { current: doing };
         const id = `${proc.pid}`;
         const cached = activityCache.get(id);
-        const activity = deriveStateWithHold({
+        const kind = inferKind(cmdRaw);
+        const activity = deriveOpenCodeState({
             cpu,
             hasError,
-            lastEventAt,
+            lastEventAt: lastEventAt,
             inFlight,
+            status,
+            isServer: kind === "opencode-server",
             previousActiveAt: cached?.lastActiveAt,
             now,
+            cpuThreshold,
+            eventWindowMs: opencodeEventWindowMs,
+            holdMs: opencodeHoldMs,
         });
         let state = activity.state;
-        if (statusIsError)
-            state = "error";
-        else if (statusIsActive)
-            state = "active";
-        else if (statusIsIdle)
-            state = "idle";
-        const hasSignal = statusIsActive ||
-            statusIsIdle ||
+        const hasSignal = statusIsIdle ||
             statusIsError ||
             typeof lastEventAt === "number" ||
-            !!inFlight;
+            typeof inFlight === "boolean";
         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 });
+        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 startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
         const computedTitle = sessionTitle || deriveTitle(doing, repoName, proc.pid, kind);
         const safeSummary = sanitizeSummary(summary);
@@ -559,6 +592,60 @@ export async function scanCodexProcesses() {
             events,
         });
     }
+    for (const proc of claudeProcs) {
+        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 claudeInfo = summarizeClaudeCommand(cmdRaw);
+        const doing = claudeInfo?.doing ||
+            parseDoingFromCmd(cmdRaw) ||
+            shortenCmd(cmdRaw || proc.name || "");
+        const summary = doing ? { current: doing } : undefined;
+        const model = claudeInfo?.model;
+        const cwdRaw = cwds.get(proc.pid);
+        const cwd = redactText(cwdRaw) || cwdRaw;
+        const repoRoot = cwdRaw ? findRepoRoot(cwdRaw) : null;
+        const repoName = repoRoot ? path.basename(repoRoot) : undefined;
+        const kind = claudeInfo?.kind || inferKind(cmdRaw);
+        const id = `${proc.pid}`;
+        const cached = activityCache.get(id);
+        const activity = deriveClaudeState({
+            cpu,
+            info: claudeInfo,
+            previousActiveAt: cached?.lastActiveAt,
+            now,
+        });
+        const state = activity.state;
+        activityCache.set(id, { lastActiveAt: state === "active" ? activity.lastActiveAt : undefined, lastSeenAt: now });
+        seenIds.add(id);
+        const cmd = redactText(cmdRaw) || cmdRaw;
+        const cmdShort = shortenCmd(cmd);
+        const startedAt = startMs ? Math.floor(startMs / 1000) : undefined;
+        const computedTitle = deriveTitle(doing, repoName, proc.pid, kind);
+        const safeSummary = sanitizeSummary(summary);
+        agents.push({
+            id,
+            pid: proc.pid,
+            startedAt,
+            title: redactText(computedTitle) || computedTitle,
+            cmd,
+            cmdShort,
+            kind,
+            cpu,
+            mem,
+            state,
+            doing: redactText(doing) || doing,
+            repo: repoName,
+            cwd,
+            model,
+            summary: safeSummary,
+        });
+    }
     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.4",
+  "version": "0.1.5",
   "private": false,
   "license": "Apache-2.0",
   "repository": {

package/public/app.js

@@ -21,15 +21,55 @@ const gridScale = 2;
 const query = new URLSearchParams(window.location.search);
 const mockMode = query.get("mock") === "1";
 
-const statePalette = {
-  active: { top: "#3d8f7f", left: "#2d6d61", right: "#275b52", stroke: "#54cdb1" },
-  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 cliPalette = {
+  codex: {
+    agent: {
+      active: { top: "#3d8f7f", left: "#2d6d61", right: "#275b52", stroke: "#54cdb1" },
+      idle: { top: "#384a57", left: "#2b3943", right: "#25323b", stroke: "#4f6b7a" },
+      error: { top: "#82443c", left: "#6d3530", right: "#5a2c28", stroke: "#d1584b" },
+    },
+    server: {
+      active: { top: "#4e665e", left: "#3d524b", right: "#32453f", stroke: "#79b8a8" },
+      idle: { top: "#353f48", left: "#2a323a", right: "#232a30", stroke: "#526577" },
+      error: { top: "#82443c", left: "#6d3530", right: "#5a2c28", stroke: "#d1584b" },
+    },
+    accent: "#57f2c6",
+    accentStrong: "rgba(87, 242, 198, 0.6)",
+    accentSoft: "rgba(87, 242, 198, 0.35)",
+    glow: "87, 242, 198",
+  },
+  opencode: {
+    agent: {
+      active: { top: "#8a6a2f", left: "#6f5626", right: "#5b4621", stroke: "#f1bd4f" },
+      idle: { top: "#3c3a37", left: "#2f2d2a", right: "#262322", stroke: "#7f6f56" },
+      error: { top: "#86443b", left: "#70352f", right: "#5c2c28", stroke: "#e0705c" },
+    },
+    server: {
+      active: { top: "#7d6a2b", left: "#665725", right: "#54481f", stroke: "#f5c453" },
+      idle: { top: "#353b42", left: "#272c33", right: "#1f242a", stroke: "#6b7380" },
+      error: { top: "#86443b", left: "#70352f", right: "#5c2c28", stroke: "#e0705c" },
+    },
+    accent: "#f5c453",
+    accentStrong: "rgba(245, 196, 83, 0.6)",
+    accentSoft: "rgba(245, 196, 83, 0.35)",
+    glow: "245, 196, 83",
+  },
+  claude: {
+    agent: {
+      active: { top: "#3f6fa3", left: "#2f5580", right: "#25476a", stroke: "#7fb7ff" },
+      idle: { top: "#374252", left: "#2a323f", right: "#232a35", stroke: "#5c6f85" },
+      error: { top: "#7f4140", left: "#683334", right: "#552a2b", stroke: "#e06b6a" },
+    },
+    server: {
+      active: { top: "#4b5f74", left: "#3a4a5c", right: "#2f3d4d", stroke: "#91b4d6" },
+      idle: { top: "#323b47", left: "#262d36", right: "#20262d", stroke: "#556577" },
+      error: { top: "#7f4140", left: "#683334", right: "#552a2b", stroke: "#e06b6a" },
+    },
+    accent: "#7fb7ff",
+    accentStrong: "rgba(127, 183, 255, 0.6)",
+    accentSoft: "rgba(127, 183, 255, 0.35)",
+    glow: "127, 183, 255",
+  },
 };
 const stateOpacity = {
   active: 1,
@@ -222,19 +262,38 @@ function isServerKind(kind) {
   return kind === "app-server" || kind === "opencode-server";
 }
 
+function cliForAgent(agent) {
+  const kind = agent.kind || "";
+  if (kind.startsWith("opencode")) return "opencode";
+  if (kind.startsWith("claude")) return "claude";
+  return "codex";
+}
+
 function paletteFor(agent) {
-  if (isServerKind(agent.kind)) {
-    return serverPalette[agent.state] || serverPalette.idle;
-  }
-  return statePalette[agent.state] || statePalette.idle;
+  const cli = cliForAgent(agent);
+  const palette = cliPalette[cli] || cliPalette.codex;
+  const scope = isServerKind(agent.kind) ? palette.server : palette.agent;
+  return scope[agent.state] || scope.idle;
 }
 
 function accentFor(agent) {
-  return isServerKind(agent.kind) ? "#f5c453" : "#57f2c6";
+  const cli = cliForAgent(agent);
+  return (cliPalette[cli] || cliPalette.codex).accent;
+}
+
+function accentStrongFor(agent) {
+  const cli = cliForAgent(agent);
+  return (cliPalette[cli] || cliPalette.codex).accentStrong;
+}
+
+function accentSoftFor(agent) {
+  const cli = cliForAgent(agent);
+  return (cliPalette[cli] || cliPalette.codex).accentSoft;
 }
 
 function accentGlow(agent, alpha) {
-  const tint = isServerKind(agent.kind) ? "245, 196, 83" : "87, 242, 198";
+  const cli = cliForAgent(agent);
+  const tint = (cliPalette[cli] || cliPalette.codex).glow;
   return `rgba(${tint}, ${alpha})`;
 }
 
@@ -324,9 +383,12 @@ function renderLaneList(items, container, emptyLabel) {
       const doingRaw = agent.summary?.current || agent.doing || agent.cmdShort || "";
       const doing = escapeHtml(truncate(doingRaw, 80));
       const selectedClass = selected && selected.id === agent.id ? "is-selected" : "";
+      const accent = accentFor(agent);
+      const accentGlow = accentSoftFor(agent);
+      const cli = cliForAgent(agent);
       const label = escapeHtml(labelFor(agent));
       return `
-        <button class="lane-item ${selectedClass}" type="button" data-id="${agent.id}">
+        <button class="lane-item ${selectedClass} cli-${cli}" type="button" data-id="${agent.id}" style="--cli-accent: ${accent}; --cli-accent-glow: ${accentGlow};">
           <div class="lane-pill ${agent.state}"></div>
           <div class="lane-copy">
             <div class="lane-label">${label}</div>
@@ -490,8 +552,8 @@ function draw() {
     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 accentStrong = accentStrongFor(item.agent);
+    const accentSoft = accentSoftFor(item.agent);
     const pulse =
       isActive && !reducedMotion
         ? 4 + Math.sin(time / 200) * 3

package/public/style.css

@@ -295,12 +295,15 @@ body {
 }
 
 .lane-item {
+  --cli-accent: rgba(87, 242, 198, 0.7);
+  --cli-accent-glow: rgba(87, 242, 198, 0.25);
   display: flex;
   align-items: flex-start;
   gap: 10px;
   padding: 10px;
   border-radius: 10px;
   border: 1px solid rgba(62, 78, 89, 0.5);
+  border-left: 3px solid var(--cli-accent);
   background: rgba(13, 17, 22, 0.85);
   cursor: pointer;
   text-align: left;
@@ -312,16 +315,18 @@ body {
 }
 
 .lane-item:hover {
-  border-color: rgba(87, 242, 198, 0.5);
+  border-color: var(--cli-accent);
+  border-left-color: var(--cli-accent);
 }
 
 .lane-item.is-selected {
-  border-color: rgba(87, 242, 198, 0.7);
-  box-shadow: 0 0 12px rgba(87, 242, 198, 0.25);
+  border-color: var(--cli-accent);
+  border-left-color: var(--cli-accent);
+  box-shadow: 0 0 12px var(--cli-accent-glow);
 }
 
 .lane-item:focus-visible {
-  outline: 2px solid rgba(87, 242, 198, 0.6);
+  outline: 2px solid var(--cli-accent);
   outline-offset: 2px;
 }