feinai 0.8.2 → 0.8.4

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.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
+
+- **Contador de agentes activos en el navbar.** Pill junto a los stats del header (`#agents-pill`), visible en cualquier ruta gracias a un poll global independiente (`pollAgentsGlobal`, cada 5s) que no se detiene al navegar entre páginas. Muestra el total de procesos matcheados y, en el tooltip, cuántos están verificados contra el worktree real vs. sólo matcheados por id de tarea.
+
+### Fixed
+
+- **El contador de tiempo transcurrido de una tarea siempre arrancaba en ~120m.** `datetime('now')` de SQLite devuelve timestamps UTC sin marcador de zona (`"YYYY-MM-DD HH:MM:SS"`); `new Date(...)` los parseaba como hora local, corriendo todos los cálculos de tiempo por el offset UTC de la máquina (2h en este caso). Se agregó `parseServerDate()`, que interpreta cualquier timestamp sin zona explícita como UTC, y se usa ahora en `relativeTime`, `elapsedSince` y en el umbral de color de `tickElapsed`.
+
+### Changed
+
+- **Auditoría del detector de "agentes activos" (`src/agents-status.ts`).** El matching anterior era: grep de `ps` machine-wide por substring `TASK-...` (sin scope de proyecto), sin verificar que el proceso realmente corriera en el worktree de esa tarea, y sólo tomaba el primer proceso matcheado por tarea (`.find`), descartando el resto en silencio. Ahora `listAgentProcesses` recibe los pares `{taskId, worktree}` de las tareas `in_progress` (vía `/api/agents` → `listTasks(db, { status: "in_progress" })`), verifica cada match leyendo `/proc/:pid/cwd` contra el worktree esperado, agrega todos los procesos que matchean una misma tarea (no sólo el primero) y expone un flag `verified` por proceso. El dashboard ahora muestra cpu/mem agregados, la cantidad de procesos, un badge "unverified" cuando ningún match fue confirmado por cwd, y un badge "no process detected" cuando una tarea `in_progress` no tiene ningún proceso asociado (agente huérfano/caído).
+- Auditado el criterio de creación de logs de requests (`logRequest` en `src/server.ts`): confirmado correcto — suprime cualquier GET del actor `dashboard` (evita el loop de refresh ya arreglado en 0.8.2) y sigue logueando toda mutación y todo request no-dashboard; no se encontraron imprecisiones adicionales.
+
 ## [0.8.2] - 2026-09-02
 
 ### Fixed

package/package.json

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

package/src/agents-status.ts

@@ -1,26 +1,108 @@
+import { readdir, readlink } from "node:fs/promises";
+
 export interface AgentProcess {
   pid: number;
   cpu: number;
   mem: number;
   command: string;
   taskId: string | null;
+  /** true if the process's cwd was confirmed inside the task's worktree */
+  verified: boolean;
+}
+
+export interface ExpectedAgent {
+  taskId: string;
+  /** absolute path to the task's worktree, or null if it has none */
+  worktree: string | null;
+}
+
+interface PsRow {
+  pid: number;
+  cpu: number;
+  mem: number;
+  command: string;
 }
 
-export async function listAgentProcesses(): Promise<AgentProcess[]> {
+async function psSnapshot(): Promise<PsRow[]> {
   try {
-    const result = await Bun.$`ps -eo pid,pcpu,pmem,command | grep -E 'TASK-[A-Z0-9-]+' | grep -v grep`.text();
-    const lines = result.trim().split("\n").filter(Boolean);
-    return lines.map((line) => {
-      const parts = line.trim().split(/\s+/);
-      const pid = parseInt(parts[0]!, 10);
-      const cpu = parseFloat(parts[1]!);
-      const mem = parseFloat(parts[2]!);
-      const command = parts.slice(3).join(" ");
-      const taskMatch = command.match(/TASK-[A-Z0-9-]+/);
-      const taskId = taskMatch ? taskMatch[0] : null;
-      return { pid, cpu, mem, command, taskId };
-    }).filter((p) => Number.isFinite(p.pid));
+    const result = await Bun.$`ps -eo pid,pcpu,pmem,command`.text();
+    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 [];
   }
 }
+
+/**
+ * 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 pids = await readdir("/proc").catch(() => [] as string[]);
+  const numericPids = new Set(pids.filter((p) => /^\d+$/.test(p)).map(Number));
+
+  const cwdByPid = new Map<number, string>();
+  await Promise.all(
+    rows
+      .filter((r) => numericPids.has(r.pid))
+      .map(async (r) => {
+        try {
+          cwdByPid.set(r.pid, await readlink(`/proc/${r.pid}/cwd`));
+        } catch {
+          // process exited or unreadable — no cwd signal for it
+        }
+      }),
+  );
+
+  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.2";
+const VERSION = "0.8.4";
 
 interface ParsedArgs {
   positional: string[];

package/src/dashboard.html

@@ -106,6 +106,9 @@
     .stat.failed .dot { background: var(--red); }
     .stat .count { font-weight: 600; }
     .stat .label { color: var(--fg-dim); transition: color 0.1s; }
+    .stat.agents .dot { background: var(--gray); }
+    .stat.agents.live .dot { background: var(--green); animation: ripple 1.5s ease-out infinite; }
+    .stat.agents .count[title] { cursor: help; }
 
     .header-actions { display: flex; gap: 8px; align-items: center; }
     .search-wrap { position: relative; }
@@ -591,6 +594,7 @@
         feinai
       </a>
       <div class="stats" id="stats"></div>
+      <button class="stat agents" id="agents-pill" data-goto="#/" title="Active agent processes"></button>
       <div class="header-actions">
         <div class="search-wrap">
           <input class="search-box" id="search" placeholder="Search specs and tasks" autocomplete="off" aria-label="Search specs and tasks">
@@ -664,17 +668,33 @@
         ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[c]));
     }
 
+    // SQLite's datetime('now') returns "YYYY-MM-DD HH:MM:SS" in UTC with no
+    // timezone marker. Handed to `new Date()` as-is, the browser parses it as
+    // LOCAL time instead — silently shifting every server timestamp by the
+    // local UTC offset (e.g. a freshly claimed task's elapsed counter always
+    // "starting" at ~2h in a UTC+2 timezone). Treat any zone-less timestamp
+    // from the server as UTC.
+    function parseServerDate(s) {
+      if (!s) return null;
+      const hasZone = /Z$|[+-]\d\d:?\d\d$/.test(s);
+      const d = new Date(hasZone ? s : s.replace(" ", "T") + "Z");
+      return Number.isNaN(d.getTime()) ? null : d;
+    }
+
     function relativeTime(dateStr) {
-      const diff = Date.now() - new Date(dateStr).getTime();
+      const d = parseServerDate(dateStr);
+      if (!d) return "";
+      const diff = Date.now() - d.getTime();
       if (diff < 60000) return "just now";
       if (diff < 3600000) return Math.floor(diff / 60000) + "m ago";
       if (diff < 86400000) return Math.floor(diff / 3600000) + "h ago";
-      return new Date(dateStr).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+      return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
     }
 
     function elapsedSince(iso) {
-      if (!iso) return "";
-      const ms = Date.now() - new Date(iso).getTime();
+      const d = parseServerDate(iso);
+      if (!d) return "";
+      const ms = Date.now() - d.getTime();
       if (ms < 0) return "0s";
       const m = Math.floor(ms / 60000);
       const s = Math.floor((ms % 60000) / 1000);
@@ -1604,21 +1624,22 @@
         const iso = el.getAttribute("data-elapsed");
         if (!iso) { el.textContent = ""; return; }
         el.textContent = elapsedSince(iso);
-        const minutes = Math.floor((Date.now() - new Date(iso).getTime()) / 60000);
+        const d = parseServerDate(iso);
+        const minutes = d ? Math.floor((Date.now() - d.getTime()) / 60000) : 0;
         el.style.color = minutes >= 60 ? "var(--red)" : minutes >= 30 ? "var(--yellow)" : "var(--fg-dim)";
       });
     }
 
     async function pollWorktreeStatus(ids) {
       if (!ids.length) return;
-      const [results, agents] = await Promise.all([
-        Promise.allSettled(ids.map(async (id) => ({
-          id,
-          data: await api("GET", `/api/tasks/${encodeURIComponent(id)}/worktree-status`),
-        }))),
-        api("GET", "/api/agents").catch(() => []),
-      ]);
-      agentProcesses = Array.isArray(agents) ? agents : [];
+      // Agent process data comes from the global agentsPillTimer poll
+      // (pollAgentsGlobal) rather than being re-fetched here, so the navbar
+      // pill and the worktree cards always agree and we don't double the
+      // `ps` calls every 5s.
+      const results = await Promise.allSettled(ids.map(async (id) => ({
+        id,
+        data: await api("GET", `/api/tasks/${encodeURIComponent(id)}/worktree-status`),
+      })));
       for (const r of results) if (r.status === "fulfilled") updateWorktreeCard(r.value.id, r.value.data);
     }
 
@@ -1643,7 +1664,7 @@
       const card = badgeEl.closest(".worktree-card");
       if (card) card.dataset.cardState = state.cls;
 
-      const agent = agentProcesses.find((a) => a.taskId === id);
+      const matches = agentProcesses.filter((a) => a.taskId === id);
       if (processEl) {
         const ownerEl = card?.querySelector(".owner");
         const ownerType = ownerEl?.dataset.ownerType ?? null;
@@ -1651,9 +1672,19 @@
         const ownerTag = ownerType && ownerPid
           ? `<span>${escapeHtml(ownerType)}</span><span>pid ${escapeHtml(ownerPid)}</span>`
           : "";
-        processEl.innerHTML = agent
-          ? `${ownerTag}<span>${agent.cpu}% cpu</span><span>${agent.mem}% mem</span>`
-          : ownerTag;
+        let procTag = "";
+        if (matches.length) {
+          const cpu = matches.reduce((sum, a) => sum + (a.cpu || 0), 0);
+          const mem = matches.reduce((sum, a) => sum + (a.mem || 0), 0);
+          const anyVerified = matches.some((a) => a.verified);
+          const title = anyVerified
+            ? "process cwd confirmed inside this task's worktree"
+            : "matched by task id in the command line only — cwd could not be confirmed";
+          procTag = `<span title="${title}">${matches.length > 1 ? `${matches.length} procs · ` : ""}${cpu.toFixed(1)}% cpu</span><span>${mem.toFixed(1)}% mem</span>${anyVerified ? "" : `<span class="worktree-state" style="opacity:0.7" title="${title}">unverified</span>`}`;
+        } else if (card?.dataset.cardState !== "merged" && card?.dataset.cardState !== "removed") {
+          procTag = `<span class="worktree-state not-created" title="task is in_progress but no matching process was found — it may have exited or crashed">no process detected</span>`;
+        }
+        processEl.innerHTML = ownerTag + procTag;
       }
       if (filesEl) {
         filesEl.innerHTML = data.files?.length
@@ -1681,6 +1712,38 @@
       $("#stats").innerHTML = rows.join("");
     }
 
+    // Global navbar "active agents" pill. Independent of the per-page
+    // worktree-card polling (mountWorktreeCards/pollWorktreeStatus) so the
+    // count stays live on every route, not just the overview — and NOT
+    // cleared by stopLiveTimers(), which runs on every navigation.
+    let agentsPillTimer = null;
+
+    function renderAgentsPill() {
+      const el = $("#agents-pill");
+      if (!el) return;
+      const total = agentProcesses.length;
+      const verified = agentProcesses.filter((a) => a.verified).length;
+      const unverified = total - verified;
+      el.classList.toggle("live", total > 0);
+      const title = total === 0
+        ? "No active agent processes detected"
+        : unverified > 0
+          ? `${verified} verified in their task's worktree, ${unverified} matched by task id only (unconfirmed)`
+          : `${verified} verified in their task's worktree`;
+      el.title = title;
+      el.innerHTML = `<span class="dot"></span><span class="count" title="${escapeHtml(title)}">${total}</span><span class="label">active ${total === 1 ? "agent" : "agents"}</span>`;
+    }
+
+    async function pollAgentsGlobal() {
+      try {
+        const agents = await api("GET", "/api/agents");
+        agentProcesses = Array.isArray(agents) ? agents : [];
+      } catch {
+        agentProcesses = [];
+      }
+      renderAgentsPill();
+    }
+
     // ================= Render =================
     const ROUTES = [
       { match: (s) => s.length === 0, page: pageOverview },
@@ -1801,6 +1864,8 @@
     render();
     connectSse();
     api("GET", "/api/context").then((ctx) => { appContext = ctx; }).catch(() => {});
+    pollAgentsGlobal();
+    agentsPillTimer = setInterval(pollAgentsGlobal, 5000);
   </script>
 </body>
 </html>

package/src/server.ts

@@ -441,9 +441,17 @@ 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 agents = await listAgentProcesses();
+          const inProgress = listTasks(db, { status: "in_progress" });
+          // 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);
         }