feinai 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.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.3",
   "description": "Task & spec manager for AI agents — parallel worktrees, live dashboard, SDD skills",
   "type": "module",
   "bin": {

package/src/agents-status.ts

@@ -1,26 +1,79 @@
+import { 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;
+  worktree: string | null;
 }
 
-export async function listAgentProcesses(): Promise<AgentProcess[]> {
+/**
+ * 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[];
   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();
+    lines = result.trim().split("\n").slice(1).filter(Boolean);
   } catch {
     return [];
   }
+
+  const worktreeByTask = new Map(
+    expected
+      .filter((e): e is ExpectedAgent & { worktree: string } => !!e.worktree)
+      .map((e) => [e.taskId, e.worktree]),
+  );
+
+  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 results = await Promise.all(
+    candidates.map(async (c) => {
+      const worktree = c.taskId ? worktreeByTask.get(c.taskId) : undefined;
+      let verified = false;
+      if (worktree) {
+        try {
+          const cwd = await readlink(`/proc/${c.pid}/cwd`);
+          verified = cwd === worktree || cwd.startsWith(worktree + "/");
+        } catch {
+          verified = false;
+        }
+      }
+      return { ...c, verified };
+    }),
+  );
+
+  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.3";
 
 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

@@ -443,7 +443,9 @@ export function startServer(opts: ServerOptions): { url: string; stop: () => voi
 
         // GET /api/agents — running opencode processes with task matching
         if (path === "/api/agents" && method === "GET") {
-          const agents = await listAgentProcesses();
+          const inProgress = listTasks(db, { status: "in_progress" });
+          const expected = inProgress.map((t) => ({ taskId: t.id, worktree: t.worktree }));
+          const agents = await listAgentProcesses(expected);
           return json(agents);
         }