feinai 0.8.3 → 0.8.5

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [0.8.5] - 2026-09-07
+
+### Fixed
+
+- **Contador "active agents" del navbar sobrecontaba y oscilaba.** El pill sumaba `agentProcesses.length`, es decir, todos los procesos con cwd dentro de un worktree — pero una sesión de agente real suele lanzar procesos hijos (`git`, `bun`, `rg`, `tsc`, ...) que también quedan momentáneamente con cwd en ese worktree y se contaban como agentes separados. Esto inflaba el número (ej. 5 en vez de 1) y lo hacía oscilar entre polls de 5s a medida que esos hijos aparecían y desaparecían, mientras que la card de un task individual sólo reflejaba ese task puntual. `renderAgentsPill()` ahora agrupa por `taskId` y cuenta tasks distintas con al menos un proceso matcheado, en línea con lo que ya mostraba cada worktree card.
+
+## [0.8.4] - 2026-09-02
+
+### Fixed
+
+- **Detección de agentes activos no reflejaba agentes reales.** El matching en 0.8.3 seguía dependiendo de encontrar el substring `TASK-...` en la línea de comando del proceso — pero sesiones reales (`claude`, `opencode` corriendo cd'd al worktree de la tarea) casi nunca tienen el task id en su `argv`, así que nunca matcheaban. Además `task.worktree` se guarda relativo al root del proyecto (`.worktrees/TASK-XXX`) y se comparaba tal cual contra rutas absolutas de `/proc/:pid/cwd`, que tampoco matcheaban nunca. `listAgentProcesses` ahora usa el cwd del proceso como señal primaria: escanea `/proc/*/cwd` de todos los procesos y los compara contra el worktree absoluto de cada tarea `in_progress` (resuelto en `server.ts` con `resolve(process.cwd(), task.worktree)`). El grep por `TASK-...` en el comando queda sólo como fallback de baja confianza (`verified: false`) para tareas sin worktree.
+
 ## [0.8.3] - 2026-09-02
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "feinai",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Task & spec manager for AI agents — parallel worktrees, live dashboard, SDD skills",
   "type": "module",
   "bin": {

package/src/agents-status.ts

@@ -1,4 +1,4 @@
-import { readlink } from "node:fs/promises";
+import { readdir, readlink } from "node:fs/promises";
 
 export interface AgentProcess {
   pid: number;
@@ -12,68 +12,97 @@ export interface AgentProcess {
 
 export interface ExpectedAgent {
   taskId: string;
+  /** absolute path to the task's worktree, or null if it has none */
   worktree: string | null;
 }
 
-/**
- * Snapshot of processes that look like they're working on active tasks.
- *
- * Matching is done two ways:
- * 1. By worktree cwd (`/proc/:pid/cwd`) against each expected task's worktree
- *    path — this is the precise signal and sets `verified: true`.
- * 2. By a `TASK-...` substring in the command line — kept as a fallback so we
- *    don't lose visibility into agents whose cwd we can't resolve (e.g. the
- *    process already exited, or /proc isn't readable), but reported as
- *    `verified: false` since a substring match can be coincidental or belong
- *    to an unrelated project using the same task ID scheme.
- */
-export async function listAgentProcesses(
-  expected: ExpectedAgent[] = [],
-): Promise<AgentProcess[]> {
-  let lines: string[];
+interface PsRow {
+  pid: number;
+  cpu: number;
+  mem: number;
+  command: string;
+}
+
+async function psSnapshot(): Promise<PsRow[]> {
   try {
     const result = await Bun.$`ps -eo pid,pcpu,pmem,command`.text();
-    lines = result.trim().split("\n").slice(1).filter(Boolean);
+    return result
+      .trim()
+      .split("\n")
+      .slice(1)
+      .map((line) => {
+        const parts = line.trim().split(/\s+/);
+        return {
+          pid: parseInt(parts[0]!, 10),
+          cpu: parseFloat(parts[1]!),
+          mem: parseFloat(parts[2]!),
+          command: parts.slice(3).join(" "),
+        };
+      })
+      .filter((p) => Number.isFinite(p.pid));
   } catch {
     return [];
   }
+}
 
-  const worktreeByTask = new Map(
-    expected
-      .filter((e): e is ExpectedAgent & { worktree: string } => !!e.worktree)
-      .map((e) => [e.taskId, e.worktree]),
-  );
+/**
+ * Snapshot of processes working on active tasks.
+ *
+ * Real agent sessions here (an interactive `claude` or `opencode` process cd'd
+ * into a task's git worktree) rarely put the task ID anywhere in their
+ * command line — so grepping ps output for `TASK-...` misses them entirely.
+ * The reliable signal is the process's current working directory: for each
+ * in_progress task with a worktree, we check every process's
+ * `/proc/:pid/cwd` against that worktree path. A cwd match is `verified: true`.
+ *
+ * As a fallback (e.g. a task has no worktree yet, or /proc isn't readable),
+ * we also look for a literal `TASK-...` substring in the command line —
+ * kept as `verified: false` since it's coincidental at best.
+ */
+export async function listAgentProcesses(
+  expected: ExpectedAgent[] = [],
+): Promise<AgentProcess[]> {
+  const rows = await psSnapshot();
+  if (!rows.length) return [];
 
-  const candidates: Omit<AgentProcess, "verified">[] = [];
-  for (const line of lines) {
-    const parts = line.trim().split(/\s+/);
-    if (parts.length < 4) continue;
-    const pid = parseInt(parts[0]!, 10);
-    const cpu = parseFloat(parts[1]!);
-    const mem = parseFloat(parts[2]!);
-    const command = parts.slice(3).join(" ");
-    if (!Number.isFinite(pid)) continue;
-    const taskMatch = command.match(/TASK-[A-Z0-9-]+/);
-    const taskId = taskMatch ? taskMatch[0] : null;
-    if (!taskId) continue;
-    candidates.push({ pid, cpu, mem, command, taskId });
-  }
+  const pids = await readdir("/proc").catch(() => [] as string[]);
+  const numericPids = new Set(pids.filter((p) => /^\d+$/.test(p)).map(Number));
 
-  const results = await Promise.all(
-    candidates.map(async (c) => {
-      const worktree = c.taskId ? worktreeByTask.get(c.taskId) : undefined;
-      let verified = false;
-      if (worktree) {
+  const cwdByPid = new Map<number, string>();
+  await Promise.all(
+    rows
+      .filter((r) => numericPids.has(r.pid))
+      .map(async (r) => {
         try {
-          const cwd = await readlink(`/proc/${c.pid}/cwd`);
-          verified = cwd === worktree || cwd.startsWith(worktree + "/");
+          cwdByPid.set(r.pid, await readlink(`/proc/${r.pid}/cwd`));
         } catch {
-          verified = false;
+          // process exited or unreadable — no cwd signal for it
         }
-      }
-      return { ...c, verified };
-    }),
+      }),
   );
 
+  const results: AgentProcess[] = [];
+  const matchedPids = new Set<number>();
+
+  for (const { taskId, worktree } of expected) {
+    if (!worktree) continue;
+    for (const row of rows) {
+      if (matchedPids.has(row.pid)) continue;
+      const cwd = cwdByPid.get(row.pid);
+      if (!cwd) continue;
+      if (cwd === worktree || cwd.startsWith(worktree + "/")) {
+        matchedPids.add(row.pid);
+        results.push({ ...row, taskId, verified: true });
+      }
+    }
+  }
+
+  for (const row of rows) {
+    if (matchedPids.has(row.pid)) continue;
+    const taskMatch = row.command.match(/TASK-[A-Z0-9-]+/);
+    if (!taskMatch) continue;
+    results.push({ ...row, taskId: taskMatch[0], verified: false });
+  }
+
   return results;
 }

package/src/cli.ts

@@ -57,7 +57,7 @@ import {
   type OrphanKillResult,
 } from "./server-state";
 
-const VERSION = "0.8.3";
+const VERSION = "0.8.4";
 
 interface ParsedArgs {
   positional: string[];

package/src/dashboard.html

@@ -1721,8 +1721,18 @@
     function renderAgentsPill() {
       const el = $("#agents-pill");
       if (!el) return;
-      const total = agentProcesses.length;
-      const verified = agentProcesses.filter((a) => a.verified).length;
+      // Group by taskId: a single agent session commonly spawns child
+      // processes (git, bun, rg, tsc, ...) whose cwd also lands inside the
+      // worktree, so agentProcesses.length overcounts and flickers as those
+      // children come and go. What "active agents" means is distinct tasks
+      // with at least one matched process.
+      const byTask = new Map();
+      for (const a of agentProcesses) {
+        if (!byTask.has(a.taskId)) byTask.set(a.taskId, []);
+        byTask.get(a.taskId).push(a);
+      }
+      const total = byTask.size;
+      const verified = [...byTask.values()].filter((procs) => procs.some((a) => a.verified)).length;
       const unverified = total - verified;
       el.classList.toggle("live", total > 0);
       const title = total === 0

package/src/server.ts

@@ -441,10 +441,16 @@ export function startServer(opts: ServerOptions): { url: string; stop: () => voi
           return json(status);
         }
 
-        // GET /api/agents — running opencode processes with task matching
+        // GET /api/agents — running agent processes with task matching
         if (path === "/api/agents" && method === "GET") {
           const inProgress = listTasks(db, { status: "in_progress" });
-          const expected = inProgress.map((t) => ({ taskId: t.id, worktree: t.worktree }));
+          // task.worktree is stored relative to the project root the server
+          // was launched from — resolve it so it can be compared against the
+          // absolute paths /proc/:pid/cwd returns.
+          const expected = inProgress.map((t) => ({
+            taskId: t.id,
+            worktree: t.worktree ? resolve(process.cwd(), t.worktree) : null,
+          }));
           const agents = await listAgentProcesses(expected);
           return json(agents);
         }