fleetlens 0.12.3 → 0.13.1

package/app/apps/web/app/api/digest/month/[yearMonth]/route.ts

@@ -2,146 +2,61 @@ import {
   runMonthDigestPipeline, readSettings,
   readMonthDigest, getCurrentMonthDigestFromCache,
 } from "@claude-lens/entries/node";
-import type { PipelineEvent } from "@claude-lens/entries/node";
-import { InflightCoalescer } from "@/lib/inflight-coalesce";
 import {
   isValidYearMonth, currentYearMonth, currentWeekMonday, todayLocal,
 } from "@/lib/entries";
-import { registerJob, updateJob, completeJob, failJob } from "@/lib/jobs";
+import {
+  handleDigestGet, handleDigestPost, jsonResponse, jsonResponseBare,
+} from "../../_shared/digest-route-helpers";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
 type Params = { params: Promise<{ yearMonth: string }> };
 
-const coalescer = new InflightCoalescer<string, void>();
-
-function updateJobFromEvent(jobId: string, ev: PipelineEvent): void {
-  if (ev.type === "status") {
-    updateJob(jobId, { progress: { phase: ev.phase, text: ev.text } });
-  } else if (ev.type === "entry") {
-    updateJob(jobId, { progress: { phase: "enrich", index: ev.index, total: ev.total } });
-  } else if (ev.type === "progress") {
-    updateJob(jobId, { progress: { phase: ev.phase, bytes: ev.bytes } });
-  }
-}
-
 export async function GET(_req: Request, ctx: Params) {
   const { yearMonth } = await ctx.params;
-  if (!isValidYearMonth(yearMonth)) {
-    return new Response(JSON.stringify({ error: "invalid year-month" }), {
-      status: 400, headers: { "content-type": "application/json" },
-    });
-  }
-  if (yearMonth > currentYearMonth()) {
-    return new Response(JSON.stringify({ error: "future month" }), { status: 400 });
-  }
-
-  const isCurrent = yearMonth === currentYearMonth();
-  if (isCurrent) {
-    const cached = getCurrentMonthDigestFromCache(yearMonth, Date.now());
-    if (cached) {
-      return new Response(JSON.stringify(cached), {
-        status: 200, headers: { "content-type": "application/json" },
-      });
-    }
-    return new Response(JSON.stringify({ pending: true, current: true }), {
-      status: 200, headers: { "content-type": "application/json" },
-    });
-  }
-
-  const cached = readMonthDigest(yearMonth);
-  if (cached) {
-    return new Response(JSON.stringify(cached), {
-      status: 200, headers: { "content-type": "application/json" },
-    });
-  }
-  return new Response(JSON.stringify({ pending: true }), {
-    status: 200, headers: { "content-type": "application/json" },
+  const valid = isValidYearMonth(yearMonth);
+  const isFuture = valid && yearMonth > currentYearMonth();
+  return handleDigestGet({
+    key: valid ? yearMonth : null,
+    invalidResponse: jsonResponse({ error: "invalid year-month" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future month" }, 400),
+    isCurrent: valid && yearMonth === currentYearMonth(),
+    readCurrentCache: () => getCurrentMonthDigestFromCache(yearMonth, Date.now()),
+    readPersisted: () => readMonthDigest(yearMonth),
+    pendingCurrentPayload: { pending: true, current: true },
+    currentFallsBackToPersisted: false,
   });
 }
 
 export async function POST(req: Request, ctx: Params) {
   const { yearMonth } = await ctx.params;
-  if (!isValidYearMonth(yearMonth)) {
-    return new Response(JSON.stringify({ error: "invalid year-month" }), { status: 400 });
-  }
-  if (yearMonth > currentYearMonth()) {
-    return new Response(JSON.stringify({ error: "future month" }), { status: 400 });
-  }
-
+  const valid = isValidYearMonth(yearMonth);
+  const isFuture = valid && yearMonth > currentYearMonth();
   const url = new URL(req.url);
   const force = url.searchParams.get("force") === "1";
-  const key = `month|${yearMonth}|${force ? 1 : 0}`;
-
-  const encoder = new TextEncoder();
   const settings = readSettings();
 
-  const stream = new ReadableStream({
-    async start(controller) {
-      let closed = false;
-      function send(event: PipelineEvent) {
-        if (closed) return;
-        try {
-          controller.enqueue(
-            encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`),
-          );
-        } catch { closed = true; }
-      }
-      function finish() {
-        if (!closed) {
-          try { controller.close(); } catch { /* ignore */ }
-          closed = true;
-        }
-      }
-
-      const alreadyInflight = coalescer.inflight(key);
-      let jobId: string | null = null;
-
-      try {
-        await coalescer.run(key, async () => {
-          if (alreadyInflight) return;
-          jobId = registerJob({
-            kind: "monthly.synth",
-            label: `Month digest · ${yearMonth}`,
-            target: yearMonth,
-            caller: "user",
-          });
-          updateJob(jobId, { status: "running" });
-          for await (const ev of runMonthDigestPipeline(yearMonth, {
-            settings: settings.ai_features,
-            force,
-            currentYearMonth: currentYearMonth(),
-            currentWeekMonday: currentWeekMonday(),
-            todayLocalDay: todayLocal(),
-          })) {
-            send(ev);
-            if (jobId) updateJobFromEvent(jobId, ev);
-          }
-          if (jobId) completeJob(jobId, `/insights/month-${yearMonth}`);
-        });
-
-        if (alreadyInflight) {
-          const d = readMonthDigest(yearMonth) ?? getCurrentMonthDigestFromCache(yearMonth, Date.now());
-          if (d) send({ type: "digest", digest: d });
-          send({ type: "status", phase: "persist", text: "coalesced with in-flight request" });
-        }
-      } catch (err) {
-        send({ type: "error", message: (err as Error).message });
-        if (jobId) failJob(jobId, (err as Error).message);
-      } finally {
-        try { controller.enqueue(encoder.encode(`event: done\ndata: {}\n\n`)); } catch { /* ignore */ }
-        finish();
-      }
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache, no-transform",
-      Connection: "keep-alive",
-      "X-Accel-Buffering": "no",
-    },
+  return handleDigestPost({
+    key: valid ? yearMonth : null,
+    invalidResponse: jsonResponseBare({ error: "invalid year-month" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future month" }, 400),
+    coalesceScope: "month",
+    force,
+    jobKind: "monthly.synth",
+    jobLabel: `Month digest · ${yearMonth}`,
+    resultUrl: `/insights/month-${yearMonth}`,
+    runPipeline: () => runMonthDigestPipeline(yearMonth, {
+      settings: settings.ai_features,
+      force,
+      currentYearMonth: currentYearMonth(),
+      currentWeekMonday: currentWeekMonday(),
+      todayLocalDay: todayLocal(),
+    }),
+    readDigestForCoalescedRequest: () =>
+      readMonthDigest(yearMonth) ?? getCurrentMonthDigestFromCache(yearMonth, Date.now()),
   });
 }

package/app/apps/web/app/api/digest/week/[startDate]/route.ts

@@ -2,149 +2,62 @@ import {
   runWeekDigestPipeline, readSettings,
   readWeekDigest, getCurrentWeekDigestFromCache,
 } from "@claude-lens/entries/node";
-import type { PipelineEvent } from "@claude-lens/entries/node";
-import { InflightCoalescer } from "@/lib/inflight-coalesce";
 import { asMonday, currentWeekMonday, todayLocal } from "@/lib/entries";
-import { registerJob, updateJob, completeJob, failJob } from "@/lib/jobs";
+import {
+  handleDigestGet, handleDigestPost, jsonResponse, jsonResponseBare,
+} from "../../_shared/digest-route-helpers";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
 
 type Params = { params: Promise<{ startDate: string }> };
 
-const coalescer = new InflightCoalescer<string, void>();
-
-function updateJobFromEvent(jobId: string, ev: PipelineEvent): void {
-  if (ev.type === "status") {
-    updateJob(jobId, { progress: { phase: ev.phase, text: ev.text } });
-  } else if (ev.type === "entry") {
-    updateJob(jobId, { progress: { phase: "enrich", index: ev.index, total: ev.total } });
-  } else if (ev.type === "progress") {
-    updateJob(jobId, { progress: { phase: ev.phase, bytes: ev.bytes } });
-  }
-}
-
 export async function GET(_req: Request, ctx: Params) {
   const { startDate } = await ctx.params;
   const monday = asMonday(startDate);
-  if (!monday) {
-    return new Response(JSON.stringify({ error: "invalid Monday date" }), {
-      status: 400, headers: { "content-type": "application/json" },
-    });
-  }
   const today = todayLocal();
-  if (monday > today) {
-    return new Response(JSON.stringify({ error: "future date" }), { status: 400 });
-  }
-
-  const isCurrent = monday === currentWeekMonday();
-  if (isCurrent) {
-    const cached =
-      getCurrentWeekDigestFromCache(monday, Date.now()) ?? readWeekDigest(monday);
-    if (cached) {
-      return new Response(JSON.stringify(cached), {
-        status: 200, headers: { "content-type": "application/json" },
-      });
-    }
-    return new Response(JSON.stringify({ pending: true, current: true }), {
-      status: 200, headers: { "content-type": "application/json" },
-    });
-  }
-
-  const cached = readWeekDigest(monday);
-  if (cached) {
-    return new Response(JSON.stringify(cached), {
-      status: 200, headers: { "content-type": "application/json" },
-    });
-  }
-  return new Response(JSON.stringify({ pending: true }), {
-    status: 200, headers: { "content-type": "application/json" },
+  const isFuture = monday !== null && monday > today;
+  return handleDigestGet({
+    key: monday,
+    invalidResponse: jsonResponse({ error: "invalid Monday date" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future date" }, 400),
+    isCurrent: monday !== null && monday === currentWeekMonday(),
+    readCurrentCache: () =>
+      monday !== null ? getCurrentWeekDigestFromCache(monday, Date.now()) : null,
+    readPersisted: () => (monday !== null ? readWeekDigest(monday) : null),
+    pendingCurrentPayload: { pending: true, current: true },
+    currentFallsBackToPersisted: true,
   });
 }
 
 export async function POST(req: Request, ctx: Params) {
   const { startDate } = await ctx.params;
   const monday = asMonday(startDate);
-  if (!monday) {
-    return new Response(JSON.stringify({ error: "invalid Monday date" }), { status: 400 });
-  }
-  if (monday > todayLocal()) {
-    return new Response(JSON.stringify({ error: "future date" }), { status: 400 });
-  }
-
+  const isFuture = monday !== null && monday > todayLocal();
   const url = new URL(req.url);
   const force = url.searchParams.get("force") === "1";
-  const key = `week|${monday}|${force ? 1 : 0}`;
-
-  const encoder = new TextEncoder();
   const settings = readSettings();
 
-  const stream = new ReadableStream({
-    async start(controller) {
-      let closed = false;
-      function send(event: PipelineEvent) {
-        if (closed) return;
-        try {
-          controller.enqueue(
-            encoder.encode(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`),
-          );
-        } catch {
-          closed = true;
-        }
-      }
-      function finish() {
-        if (!closed) {
-          try { controller.close(); } catch { /* ignore */ }
-          closed = true;
-        }
-      }
-
-      const alreadyInflight = coalescer.inflight(key);
-      let jobId: string | null = null;
-
-      try {
-        await coalescer.run(key, async () => {
-          if (alreadyInflight) return;
-          jobId = registerJob({
-            kind: "weekly.synth",
-            label: `Week digest · ${monday}`,
-            target: monday,
-            caller: "user",
-          });
-          updateJob(jobId, { status: "running" });
-          for await (const ev of runWeekDigestPipeline(monday, {
-            settings: settings.ai_features,
-            force,
-            currentWeekMonday: currentWeekMonday(),
-            todayLocalDay: todayLocal(),
-          })) {
-            send(ev);
-            if (jobId) updateJobFromEvent(jobId, ev);
-          }
-          if (jobId) completeJob(jobId, `/insights/week-${monday}`);
-        });
-
-        if (alreadyInflight) {
-          const d = readWeekDigest(monday) ?? getCurrentWeekDigestFromCache(monday, Date.now());
-          if (d) send({ type: "digest", digest: d });
-          send({ type: "status", phase: "persist", text: "coalesced with in-flight request" });
-        }
-      } catch (err) {
-        send({ type: "error", message: (err as Error).message });
-        if (jobId) failJob(jobId, (err as Error).message);
-      } finally {
-        try { controller.enqueue(encoder.encode(`event: done\ndata: {}\n\n`)); } catch { /* ignore */ }
-        finish();
-      }
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache, no-transform",
-      Connection: "keep-alive",
-      "X-Accel-Buffering": "no",
-    },
+  return handleDigestPost({
+    key: monday,
+    invalidResponse: jsonResponseBare({ error: "invalid Monday date" }, 400),
+    isFuture,
+    futureResponse: jsonResponseBare({ error: "future date" }, 400),
+    coalesceScope: "week",
+    force,
+    jobKind: "weekly.synth",
+    jobLabel: `Week digest · ${monday}`,
+    resultUrl: `/insights/week-${monday}`,
+    runPipeline: () => runWeekDigestPipeline(monday as string, {
+      settings: settings.ai_features,
+      force,
+      currentWeekMonday: currentWeekMonday(),
+      todayLocalDay: todayLocal(),
+    }),
+    readDigestForCoalescedRequest: () =>
+      monday !== null
+        ? (readWeekDigest(monday) ?? getCurrentWeekDigestFromCache(monday, Date.now()))
+        : null,
   });
 }

package/app/apps/web/app/api/events/route.ts

@@ -50,6 +50,11 @@ const HEARTBEAT_MS = 15_000;
 /** Per-file debounce so a burst of writes doesn't flood subscribers. */
 const DEBOUNCE_MS = 150;
 
+/** Subagent writes coalesce per PARENT session over a much longer window — a
+ *  16-agent workflow fan-out writes constantly, so this caps that to at most
+ *  one parent refresh every 2s instead of a storm. */
+const SUBAGENT_DEBOUNCE_MS = 2_000;
+
 export async function GET(request: Request) {
   const encoder = new TextEncoder();
 
@@ -87,9 +92,10 @@ export async function GET(request: Request) {
               const projectDir = parts[0]!;
               const fileName = parts[parts.length - 1]!;
               if (!fileName.endsWith(".jsonl")) return;
-              // Skip subagent child files under <session>/subagents/ —
-              // they're noise; the parent session file mtime changes
-              // whenever a subagent writes (Claude Code touches both).
+              // Subagent child files under <session>/subagents/ are routed to
+              // emitSubagent (throttled, mapped to the parent) by the dispatch
+              // below — this early-return is a safety net so they never go
+              // through the per-file fast path here.
               if (parts.includes("subagents")) return;
               const sessionId = fileName.replace(/\.jsonl$/, "");
 
@@ -148,6 +154,42 @@ export async function GET(request: Request) {
         );
       }
 
+      // Background-agent transcripts (`<session>/subagents/agent-*.jsonl`, and
+      // workflow agents at `<session>/subagents/workflows/<runId>/agent-*.jsonl`)
+      // are written while the parent session sits idle. Map them back to the
+      // parent and emit a session-updated so the LIVE indicator (now nested-
+      // aware via lastActivityMs) refreshes. Coalesced per-parent over a long
+      // window so a big fan-out can't flood subscribers.
+      function emitSubagent(fullPath: string) {
+        const rel = path.relative(DEFAULT_ROOT, fullPath);
+        const parts = rel.split(path.sep);
+        const subIdx = parts.lastIndexOf("subagents");
+        if (subIdx < 2) return;
+        const projectDir = parts[0]!;
+        const sessionId = parts[subIdx - 1]!;
+        const parentJsonl = path.join(DEFAULT_ROOT, projectDir, `${sessionId}.jsonl`);
+        const key = `sub:${parentJsonl}`;
+        const prev = pending.get(key);
+        if (prev) clearTimeout(prev);
+        pending.set(
+          key,
+          setTimeout(async () => {
+            pending.delete(key);
+            if (closed) return;
+            invalidateFile(parentJsonl);
+            // Report the child's fresh mtime — the parent .jsonl may be stale,
+            // and LiveRefresher dedups per source by a monotonic mtime.
+            let mtimeMs = Date.now();
+            try {
+              mtimeMs = (await fs.stat(fullPath)).mtimeMs;
+            } catch {
+              // child gone already — fall back to now.
+            }
+            send({ type: "session-updated", sessionId, projectDir, mtimeMs });
+          }, SUBAGENT_DEBOUNCE_MS),
+        );
+      }
+
       let watcher: ReturnType<typeof watch> | null = null;
       try {
         watcher = watch(
@@ -157,7 +199,8 @@ export async function GET(request: Request) {
             if (!filename) return;
             const fullPath = path.join(DEFAULT_ROOT, filename.toString());
             if (fullPath.endsWith(".jsonl")) {
-              emit(fullPath);
+              if (fullPath.includes(`${path.sep}subagents${path.sep}`)) emitSubagent(fullPath);
+              else emit(fullPath);
               return;
             }
             const base = path.basename(fullPath);

package/app/apps/web/app/globals.css

@@ -141,6 +141,29 @@ input::placeholder {
   border-radius: 6px !important;
 }
 
+/* Day-navigator step buttons on the session timeline minimap. */
+.sl-day-nav-btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 26px;
+  height: 26px;
+  border: 1px solid var(--af-border-subtle);
+  border-radius: 6px;
+  background: var(--af-surface-hover);
+  color: var(--af-text-secondary);
+  cursor: pointer;
+  transition: background 0.15s ease, opacity 0.15s ease;
+}
+.sl-day-nav-btn:hover:not(:disabled) {
+  background: var(--af-surface-elevated);
+  color: var(--af-text-primary);
+}
+.sl-day-nav-btn:disabled {
+  opacity: 0.35;
+  cursor: default;
+}
+
 /* Scrollbar */
 ::-webkit-scrollbar {
   width: 8px;

package/app/apps/web/app/insights/page.tsx

@@ -1,6 +1,8 @@
 import Link from "next/link";
 import { readSettings, readWeekDigest, interactiveLockFresh } from "@claude-lens/entries/node";
-import { lastCompletedWeekMonday, currentWeekMonday, listEntriesForDay } from "@/lib/entries";
+import { listEntryKeys } from "@claude-lens/entries/fs";
+import { parseEntryKey } from "@claude-lens/entries";
+import { lastCompletedWeekMonday, currentWeekMonday } from "@/lib/entries";
 import { WeekDigestView } from "@/components/week-digest-view";
 import { InsightsTopBar } from "@/components/insights-top-bar";
 
@@ -24,9 +26,21 @@ function weekDates(monday: string): string[] {
   return out;
 }
 
-function hasAnyEntries(monday: string): boolean {
+// Build once from the entries dir, then test the 7 weekdays against it.
+// Earlier this called listEntriesForDay per day per render, which opened
+// and parsed every matching entry file 14× before deciding the week is empty.
+function presentDays(): Set<string> {
+  const out = new Set<string>();
+  for (const key of listEntryKeys()) {
+    const parsed = parseEntryKey(key);
+    if (parsed) out.add(parsed.local_day);
+  }
+  return out;
+}
+
+function hasAnyEntries(monday: string, present: Set<string>): boolean {
   for (const d of weekDates(monday)) {
-    if (listEntriesForDay(d).length > 0) return true;
+    if (present.has(d)) return true;
   }
   return false;
 }
@@ -45,7 +59,8 @@ export default async function InsightsPage() {
   const lastWeek = lastCompletedWeekMonday();
   const cached = readWeekDigest(lastWeek);
   const prior = readWeekDigest(priorMonday(lastWeek));
-  const hasData = !!cached || hasAnyEntries(lastWeek);
+  const present = presentDays();
+  const hasData = !!cached || hasAnyEntries(lastWeek, present);
 
   // Auto-fire when AI is on and the digest isn't already cached. The interactive
   // pipeline lock (heartbeat-refreshed) suppresses concurrent fires from the
@@ -58,7 +73,7 @@ export default async function InsightsPage() {
   const prevMonday = priorMonday(lastWeek);
   const currentMonday = currentWeekMonday();
   const nextMonday = currentMonday > lastWeek ? currentMonday : null;
-  const nextHasData = nextMonday ? hasAnyEntries(nextMonday) : false;
+  const nextHasData = nextMonday ? hasAnyEntries(nextMonday, present) : false;
 
   return (
     <div style={{ paddingBottom: 64 }}>

package/app/apps/web/app/layout.tsx

@@ -78,6 +78,7 @@ export default async function RootLayout({ children }: { children: React.ReactNo
     lastAgentPreview: s.lastAgentPreview,
     firstTimestamp: s.firstTimestamp,
     lastTimestamp: s.lastTimestamp,
+    lastActivityMs: s.lastActivityMs,
     teamName: s.teamName,
     agentName: s.agentName,
     agent: s.agent,

package/app/apps/web/app/page.tsx

@@ -307,7 +307,7 @@ export default async function DashboardHome({
                         gap: 6,
                       }}
                     >
-                      <LiveBadge mtimeIso={s.lastTimestamp} />
+                      <LiveBadge mtimeIso={s.lastTimestamp} activityMs={s.lastActivityMs} />
                       <span
                         style={{
                           overflow: "hidden",