fleetlens 0.6.4 → 0.7.0

package/app/apps/web/app/sessions/[id]/session-view.tsx

@@ -39,7 +39,7 @@ import {
 } from "@claude-lens/parser";
 import { estimateCost, formatCost, formatGap, formatOffset, formatRelative, formatTokens, shortId } from "@/lib/format";
 import { LiveBadge } from "@/components/live-badge";
-import { AskClaudeButton, AskClaudeDrawer } from "@/components/ask-claude";
+import { AskButton, AskDrawer } from "@/components/ask";
 import { TailMode } from "@/components/tail-mode";
 import type { TimelineData } from "./team-tab/adapter";
 import { TeamTabClient } from "./team-tab/team-tab-client";
@@ -65,7 +65,9 @@ import {
 /*  Constants + theming                                               */
 /* ------------------------------------------------------------------ */
 
-/** Gap > this (ms) before a user row is shown as a "Session idle" divider. */
+/** Gap > this (ms) before a user row is shown as a "Session idle" divider
+ *  in the transcript body (separate from the minimap, which now derives
+ *  idle from raw event timestamps via rawIdleBands). */
 const IDLE_THRESHOLD_MS = 2000;
 
 /** Sticky header height (session header + tabs + mini-map).
@@ -150,7 +152,7 @@ export function SessionView({
   const [filter, setFilter] = useState<FilterMode>("turns");
   const [selectedIndex, setSelectedIndex] = useState<number | null>(null);
   const [selectedSubagentId, setSelectedSubagentId] = useState<string | null>(null);
-  const [askClaudeOpen, setAskClaudeOpen] = useState(false);
+  const [askOpen, setAskOpen] = useState(false);
   const [expandedTurns, setExpandedTurns] = useState<Set<number>>(new Set());
   /** When a timeline click sets the index we also want to scroll. Track that
    *  intent separately so selection via row-click doesn't auto-scroll. */
@@ -290,6 +292,76 @@ export function SessionView({
   /** Detect PR creations in this session. */
   const prMarkers = useMemo(() => detectPrMarkers(session), [session]);
 
+  /** Idle bands derived from raw event timestamps, classified per gap.
+   *
+   *  Two flavors:
+   *    - In-turn idle (gap between agent activities within the same user
+   *      turn) — multiple of these inside one turn collapse into ONE merged
+   *      band whose `start..end` spans the whole period and `durationMs`
+   *      sums the actual idle.
+   *    - Between-turn idle (gap whose terminating anchor IS a user message)
+   *      — emitted standalone. This is "user paused, walked away, came
+   *      back" time and is conceptually distinct from agent thinking.
+   *
+   *  Anchors only count user / agent / tool-call / tool-result events —
+   *  meta + thinking events are skipped so sub-second event-to-event gaps
+   *  don't crowd the strip.
+   *
+   *  Side effect: the leading warm-up gap before the first agent response
+   *  drops out unless it crosses MIN_GAP_MS — which the first 6s in a
+   *  typical Codex session does not. */
+  const rawIdleBands = useMemo(() => {
+    const isAnchor = (role: string) =>
+      role === "user" ||
+      role === "agent" ||
+      role === "tool-call" ||
+      role === "tool-result";
+    const MIN_GAP_MS = 10_000;
+    const anchors: { ms: number; role: string }[] = [];
+    for (const e of events) {
+      if (!isAnchor(e.role)) continue;
+      if (!e.timestamp) continue;
+      const ms = Date.parse(e.timestamp);
+      if (!Number.isFinite(ms)) continue;
+      anchors.push({ ms, role: e.role });
+    }
+    if (anchors.length < 2) return [];
+    anchors.sort((a, b) => a.ms - b.ms);
+    const sessionStartMs = anchors[0]!.ms - (events.find((e) => e.timestamp)?.tOffsetMs ?? 0);
+
+    type Band = { start: number; end: number; durationMs: number };
+    const bands: Band[] = [];
+    let inTurn: Band | null = null;
+
+    const flushInTurn = () => {
+      if (inTurn && inTurn.durationMs > MIN_GAP_MS) bands.push(inTurn);
+      inTurn = null;
+    };
+
+    for (let i = 1; i < anchors.length; i++) {
+      const gap = anchors[i]!.ms - anchors[i - 1]!.ms;
+      if (gap <= MIN_GAP_MS) continue;
+      const gStart = anchors[i - 1]!.ms - sessionStartMs;
+      const gEnd = anchors[i]!.ms - sessionStartMs;
+
+      if (anchors[i]!.role === "user") {
+        // Between-turn idle — close any in-progress in-turn merge first,
+        // then push the between-turn band on its own.
+        flushInTurn();
+        bands.push({ start: gStart, end: gEnd, durationMs: gap });
+      } else {
+        // In-turn idle — accumulate into the running merged band.
+        if (!inTurn) inTurn = { start: gStart, end: gEnd, durationMs: gap };
+        else {
+          inTurn.end = gEnd;
+          inTurn.durationMs += gap;
+        }
+      }
+    }
+    flushInTurn();
+    return bands;
+  }, [events]);
+
   const coldResumeMarkers = useMemo(() => {
     const seen = new Set<string>();
     const out: {
@@ -607,7 +679,7 @@ export function SessionView({
           </span>
         </div>
 
-        {/* Toolbar (filter, copy, ask-claude) */}
+        {/* Toolbar (filter, copy, ask) */}
         <div
           className="flex items-center"
           style={{
@@ -662,9 +734,9 @@ export function SessionView({
           >
             <Copy size={12} /> Copy all
           </button>
-          <AskClaudeButton
+          <AskButton
             onClick={() => {
-              setAskClaudeOpen((p) => !p);
+              setAskOpen((p) => !p);
               setSelectedIndex(null);
               setSelectedSubagentId(null);
             }}
@@ -707,6 +779,7 @@ export function SessionView({
             collapsed={collapsed}
             prMarkers={prMarkers}
             coldResumeMarkers={coldResumeMarkers}
+            rawIdleBands={rawIdleBands}
             model={model}
             selectedSubagentId={selectedSubagentId}
             onSelectSubagent={(id) => {
@@ -788,6 +861,7 @@ export function SessionView({
               isSessionLive={isSessionLive}
               team={team}
               model={model}
+              rawIdleBands={rawIdleBands}
             />
           </>
         ) : (
@@ -868,8 +942,8 @@ export function SessionView({
         );
       })()}
 
-      {/* Ask Claude drawer */}
-      {askClaudeOpen && (
+      {/* Ask drawer */}
+      {askOpen && (
         <aside
           style={{
             position: "fixed",
@@ -885,9 +959,9 @@ export function SessionView({
             flexDirection: "column",
           }}
         >
-          <AskClaudeDrawer
+          <AskDrawer
             sessionId={session.id}
-            onClose={() => setAskClaudeOpen(false)}
+            onClose={() => setAskOpen(false)}
           />
         </aside>
       )}
@@ -1285,6 +1359,7 @@ function Minimap({
   onSelectSubagent,
   prMarkers,
   coldResumeMarkers,
+  rawIdleBands,
   model,
 }: {
   displayRows: DisplayRow[];
@@ -1301,6 +1376,11 @@ function Minimap({
     tOffsetMs: number;
     info: NonNullable<SessionEvent["coldResume"]>;
   }[];
+  /** Idle bands derived directly from raw event timestamps. Used in place
+   *  of the legacy "gap before user row" heuristic so Codex sessions
+   *  (which spend most of their time in agent reasoning, not user input)
+   *  surface their dead-air on the minimap. */
+  rawIdleBands?: { start: number; end: number; durationMs: number }[];
   model?: string;
 }) {
   const WIDTH = 1400;
@@ -1456,52 +1536,66 @@ function Minimap({
       }
     }
 
+    // Build a sorted copy of idle bands so we can clip row/turn ends to
+    // the start of the next idle band (or the next row, whichever comes
+    // first). This stops a row's rectangle from spanning across an idle
+    // gap and visually swallowing it.
+    const idleBands = (rawIdleBands ?? []).slice().sort((a, b) => a.start - b.start);
+    const nextIdleStartFrom = (t: number): number | undefined => {
+      for (const b of idleBands) {
+        if (b.start >= t) return b.start;
+      }
+      return undefined;
+    };
+
     for (let i = 0; i < withTime.length; i++) {
       const item = withTime[i];
       const next = withTime[i + 1];
       const start = item.start;
-
-      // Idle gap before user rows (only in atomic view — turns already
-      // contain their idle time inside their duration).
-      if (
-        item.kind === "row" &&
-        item.row.kind === "user" &&
-        item.gapMs > IDLE_THRESHOLD_MS &&
-        out.length > 0
-      ) {
-        out.push({
-          kind: "idle",
-          start: Math.max(0, start - item.gapMs),
-          end: start,
-          durationMs: item.gapMs,
-        });
-      }
+      const nextRowStart = next?.start;
+      const nextIdleStart = nextIdleStartFrom(start + 1);
+      // Cap end to whichever comes first: next visible row, next idle band.
+      const cap = (raw: number) =>
+        Math.min(
+          raw,
+          nextRowStart ?? Number.POSITIVE_INFINITY,
+          nextIdleStart ?? Number.POSITIVE_INFINITY,
+        );
 
       if (item.kind === "turn") {
-        // Turn's end = start + duration, clamped against the next
-        // segment's start so adjacent turns don't overlap.
         const turnEnd = start + (item.turn.durationMs ?? 0);
-        const nextStart = next?.start;
-        const end = nextStart !== undefined ? Math.min(turnEnd, nextStart) : turnEnd;
         out.push({
           kind: "turn",
           turn: item.turn,
           primaryIndex: item.turn.firstPrimaryIndex,
           start,
-          end: Math.max(end, start + 1),
+          end: Math.max(cap(turnEnd), start + 1),
         });
       } else {
-        const end = next?.start ?? Math.min(start + 800, safeDur);
+        const end = cap(nextRowStart ?? start + 800);
         out.push({
           kind: "row",
           row: item.row,
           primaryIndex: rowPrimaryIndex(item.row),
           start,
-          end,
+          end: Math.max(end, start + 1),
         });
       }
     }
 
+    // Idle bands are computed from raw event timestamps (5s threshold) up
+    // in the parent — append them and let the sort below interleave by
+    // start time so they slot between rows correctly.
+    for (const band of idleBands) {
+      out.push({
+        kind: "idle",
+        start: band.start,
+        end: band.end,
+        durationMs: band.durationMs,
+      });
+    }
+    out.sort((a, b) => a.start - b.start);
+
     // Cap the number of rendered segments. Each <rect> carries two
     // event handlers (onMouseEnter + onClick), so 2000 raw-events in
     // "All events" mode becomes 4000 DOM event listeners — enough to
@@ -1546,7 +1640,7 @@ function Minimap({
       }
     }
     return bucketed;
-  }, [displayRows, safeDur]);
+  }, [displayRows, safeDur, rawIdleBands]);
 
   /* Sequential layout with a minimum displayed width per segment.
      - Raw proportional width = (seg.end - seg.start) / safeDur * WIDTH
@@ -2514,6 +2608,7 @@ function TranscriptList({
   isSessionLive,
   team,
   model,
+  rawIdleBands,
 }: {
   displayRows: DisplayRow[];
   rowRefs: React.MutableRefObject<Record<number, HTMLDivElement | null>>;
@@ -2524,6 +2619,10 @@ function TranscriptList({
   isSessionLive?: boolean;
   team?: (TimelineData & { teamName: string }) | null;
   model?: string;
+  /** Anchor-to-anchor idle bands. The body emits IdleDivider before any
+   *  row whose start matches a band's end, so Codex sessions get the same
+   *  "Session idle X minutes" markers Claude has always had. */
+  rawIdleBands?: { start: number; end: number; durationMs: number }[];
 }) {
   // Find the last collapsed turn index so we can mark it as in-progress
   // when the session is live.
@@ -2537,9 +2636,38 @@ function TranscriptList({
     }
   }
 
+  const idleBandList = (rawIdleBands ?? []).slice().sort((a, b) => a.start - b.start);
+  /** Returns the durationMs of the idle band that ends at (or just before)
+   *  the given row's tOffset, or null if no band matches. Tolerance is 1s
+   *  to absorb Date.parse rounding differences between anchor.ms and the
+   *  presentation row's tOffsetMs. */
+  const idleBeforeOffset = (tOff: number | undefined): number | null => {
+    if (tOff === undefined) return null;
+    for (const b of idleBandList) {
+      if (Math.abs(b.end - tOff) < 1000) return b.durationMs;
+    }
+    return null;
+  };
+  /** Pull a t-offset off whichever display-row variant we have. */
+  const rowTOffset = (d: DisplayRow): number | undefined => {
+    if (d.kind === "turn-collapsed" || d.kind === "turn-expanded-header") return d.turn.tOffsetMs;
+    if (d.kind === "turn-expanded-footer") return undefined;
+    return d.row.tOffsetMs;
+  };
+
   const out: React.ReactNode[] = [];
   for (let i = 0; i < displayRows.length; i++) {
     const d = displayRows[i];
+    // Emit a "Session idle" divider before any row that starts right after
+    // an anchor-to-anchor idle band. Skips indented (child) rows so an
+    // expanded turn doesn't render dividers for its inner steps.
+    const indented = d.kind === "presentation" ? d.indented : false;
+    if (!indented) {
+      const idleMs = idleBeforeOffset(rowTOffset(d));
+      if (idleMs !== null && idleMs > IDLE_THRESHOLD_MS) {
+        out.push(<IdleDivider key={`idle-before-${i}`} gapMs={idleMs} />);
+      }
+    }
 
     // Collapsed turn summary row
     if (d.kind === "turn-collapsed") {
@@ -2592,12 +2720,10 @@ function TranscriptList({
       continue;
     }
 
-    // Normal presentation row (possibly indented as a child of an expanded turn)
+    // Normal presentation row (possibly indented as a child of an expanded
+    // turn). Idle dividers are now emitted at the top of the loop from the
+    // shared rawIdleBands list — no separate gap-before-user check needed.
     const r = d.row;
-    const gap = r.gapMs ?? 0;
-    if (r.kind === "user" && gap > IDLE_THRESHOLD_MS && !d.indented) {
-      out.push(<IdleDivider key={`idle-${rowPrimaryIndex(r)}`} gapMs={gap} />);
-    }
     const idx = rowPrimaryIndex(r);
     out.push(
       <TranscriptRow
@@ -4699,7 +4825,7 @@ function EntryDayStrip({ entry }: { entry: Entry }) {
           📅 {fmtDate}
         </span>
         {isTrivial ? (
-          <OutcomePill outcome="trivial" size="md" />
+          <OutcomePill outcome="trivial" size="md" agent={entry.agent} />
         ) : isPending ? (
           <OutcomePill
             outcome={null}
@@ -4707,9 +4833,10 @@ function EntryDayStrip({ entry }: { entry: Entry }) {
             sessionId={entry.session_id}
             localDay={entry.local_day}
             size="md"
+            agent={entry.agent}
           />
         ) : enr.outcome ? (
-          <OutcomePill outcome={enr.outcome} size="md" />
+          <OutcomePill outcome={enr.outcome} size="md" agent={entry.agent} />
         ) : null}
         <span
           style={{

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

@@ -1,9 +1,20 @@
+import { homedir } from "node:os";
 import { listSessions } from "@/lib/data";
 import { buildEntriesIndex } from "@/lib/entries-index";
+import { agentSources } from "@claude-lens/parser/fs";
 import { SessionsGrid, type SessionRow } from "./sessions-grid";
 
 export const dynamic = "force-dynamic";
 
+const HOME = homedir();
+const codeStyle = {
+  fontFamily: "var(--font-mono)",
+  fontSize: 11,
+  background: "var(--af-border-subtle)",
+  padding: "1px 6px",
+  borderRadius: 4,
+} as const;
+
 export default async function SessionsPage() {
   const [sessions, index] = await Promise.all([listSessions(), buildEntriesIndex()]);
 
@@ -29,18 +40,17 @@ export default async function SessionsPage() {
           All sessions
         </h1>
         <p style={{ fontSize: 13, color: "var(--af-text-secondary)", marginTop: 4 }}>
-          {sessions.length} session{sessions.length === 1 ? "" : "s"} in{" "}
-          <code
-            style={{
-              fontFamily: "var(--font-mono)",
-              fontSize: 11,
-              background: "var(--af-border-subtle)",
-              padding: "1px 6px",
-              borderRadius: 4,
-            }}
-          >
-            ~/.claude/projects
-          </code>
+          {sessions.length} session{sessions.length === 1 ? "" : "s"} across{" "}
+          {agentSources.map((source, i) => (
+            <span key={source.kind}>
+              {i > 0 && " + "}
+              <code style={codeStyle}>
+                {source.defaultRoot.startsWith(HOME)
+                  ? "~" + source.defaultRoot.slice(HOME.length)
+                  : source.defaultRoot}
+              </code>
+            </span>
+          ))}
         </p>
       </header>
       <SessionsGrid rows={rows} />

package/app/apps/web/app/sessions/sessions-grid.tsx

@@ -1,9 +1,10 @@
 "use client";
 
 import Link from "next/link";
-import { useMemo, useState } from "react";
-import { useRouter } from "next/navigation";
-import type { SessionMeta } from "@claude-lens/parser";
+import { useCallback, useMemo } from "react";
+import { usePathname, useRouter, useSearchParams } from "next/navigation";
+import type { AgentKind, SessionMeta } from "@claude-lens/parser";
+import { getAgentMetadata, isAgentKind } from "@claude-lens/parser";
 import type { DayOutcome, EntryEnrichmentStatus } from "@claude-lens/entries";
 import {
   formatDuration,
@@ -15,6 +16,7 @@ import {
 import { Search, Wrench, MessagesSquare, Clock } from "lucide-react";
 import { LiveBadge } from "@/components/live-badge";
 import { TeamBadge } from "@/components/team-badge";
+import { AgentBadge } from "@/components/agent-badge";
 import { DataTable, type Column } from "@/components/data-table";
 import { useViewToggle } from "@/components/view-toggle";
 import { OutcomePill, outcomePriority } from "@/components/outcome-pill";
@@ -27,21 +29,66 @@ export type SessionRow = {
   latestLocalDay: string | null;
 };
 
+type SortBy = "newest" | "longest" | "most-tokens" | "outcome";
+
+const SORT_VALUES: readonly SortBy[] = ["newest", "longest", "most-tokens", "outcome"] as const;
+
+function isSortBy(s: string | null | undefined): s is SortBy {
+  return s !== null && s !== undefined && (SORT_VALUES as readonly string[]).includes(s);
+}
+
 export function SessionsGrid({ rows }: { rows: SessionRow[] }) {
   const router = useRouter();
-  const [query, setQuery] = useState("");
-  const [project, setProject] = useState("all");
-  const [sortBy, setSortBy] = useState<"newest" | "longest" | "most-tokens" | "outcome">("newest");
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+
+  // Filter state lives in the URL — back/forward replays the same view, and
+  // returning from a session detail page restores what the user had picked.
+  const query = searchParams.get("q") ?? "";
+  const project = searchParams.get("project") ?? "all";
+  const agentParam = searchParams.get("agent");
+  const agent: AgentKind | "all" = isAgentKind(agentParam) ? agentParam : "all";
+  const sortBy: SortBy = isSortBy(searchParams.get("sort"))
+    ? (searchParams.get("sort") as SortBy)
+    : "newest";
   const { mode: viewMode, toggle: viewToggle } = useViewToggle("cclens:sessions:view");
 
+  const updateParam = useCallback(
+    (key: string, value: string, fallback: string) => {
+      const next = new URLSearchParams(searchParams.toString());
+      if (!value || value === fallback) next.delete(key);
+      else next.set(key, value);
+      const qs = next.toString();
+      // replace, not push — we don't want a history entry per keystroke.
+      router.replace(qs ? `${pathname}?${qs}` : pathname, { scroll: false });
+    },
+    [pathname, router, searchParams],
+  );
+
+  const setQuery = (v: string) => updateParam("q", v, "");
+  const setProject = (v: string) => updateParam("project", v, "all");
+  const setAgent = (v: AgentKind | "all") => updateParam("agent", v, "all");
+  const setSortBy = (v: SortBy) => updateParam("sort", v, "newest");
+
   const projects = useMemo(() => {
     const s = new Set(rows.map((r) => r.session.projectName));
     return ["all", ...Array.from(s).sort()];
   }, [rows]);
 
+  const agentOptions = useMemo(() => {
+    const counts = new Map<AgentKind, number>();
+    for (const r of rows) {
+      const k = (r.session.agent ?? "claude-code") as AgentKind;
+      counts.set(k, (counts.get(k) ?? 0) + 1);
+    }
+    return Array.from(counts.entries()).sort((a, b) => b[1] - a[1]);
+  }, [rows]);
+
   const filtered = useMemo(() => {
     let items = rows.slice();
     if (project !== "all") items = items.filter((r) => r.session.projectName === project);
+    if (agent !== "all")
+      items = items.filter((r) => (r.session.agent ?? "claude-code") === agent);
     if (query) {
       const q = query.toLowerCase();
       items = items.filter(
@@ -78,7 +125,7 @@ export function SessionsGrid({ rows }: { rows: SessionRow[] }) {
     else if (sortBy === "outcome")
       items.sort((a, b) => outcomePriority(b.outcome) - outcomePriority(a.outcome));
     return items;
-  }, [rows, project, query, sortBy]);
+  }, [rows, project, agent, query, sortBy]);
 
   return (
     <div>
@@ -116,6 +163,20 @@ export function SessionsGrid({ rows }: { rows: SessionRow[] }) {
             </option>
           ))}
         </select>
+        {agentOptions.length > 1 && (
+          <select
+            value={agent}
+            onChange={(e) => setAgent(e.target.value as typeof agent)}
+            title="Filter by source agent"
+          >
+            <option value="all">All agents</option>
+            {agentOptions.map(([k, count]) => (
+              <option key={k} value={k}>
+                {agentLabel(k)} ({count})
+              </option>
+            ))}
+          </select>
+        )}
         <select value={sortBy} onChange={(e) => setSortBy(e.target.value as typeof sortBy)}>
           <option value="newest">Newest</option>
           <option value="longest">Longest</option>
@@ -196,6 +257,7 @@ const sessionTableColumns: Column<SessionRow>[] = [
             {prettyProjectName(r.session.projectName)}
           </span>
           <TeamBadge session={r.session} />
+          <AgentBadge agent={r.session.agent} />
         </div>
         <div
           style={{
@@ -319,7 +381,9 @@ const sessionTableColumns: Column<SessionRow>[] = [
 ];
 
 function OutcomeCell({ row }: { row: SessionRow }) {
-  if (row.outcome) return <OutcomePill outcome={row.outcome} size="sm" label="text" />;
+  if (row.outcome) {
+    return <OutcomePill outcome={row.outcome} size="sm" label="text" agent={row.session.agent} />;
+  }
   if (row.enrichmentStatus && row.latestLocalDay && row.enrichmentStatus !== "skipped_trivial") {
     return (
       <OutcomePill
@@ -328,6 +392,7 @@ function OutcomeCell({ row }: { row: SessionRow }) {
         sessionId={row.session.id}
         localDay={row.latestLocalDay}
         size="sm"
+        agent={row.session.agent}
       />
     );
   }
@@ -383,6 +448,7 @@ function SessionCard({ row }: { row: SessionRow }) {
             {prettyProjectName(s.projectName)}
           </span>
           <TeamBadge session={s} linkable={false} />
+          <AgentBadge agent={s.agent} />
         </div>
         <div
           style={{
@@ -400,7 +466,7 @@ function SessionCard({ row }: { row: SessionRow }) {
       {(outcome || showPending) && (
         <div onClick={(e) => e.stopPropagation()}>
           {outcome ? (
-            <OutcomePill outcome={outcome} size="md" />
+            <OutcomePill outcome={outcome} size="md" agent={s.agent} />
           ) : showPending ? (
             <OutcomePill
               outcome={null}
@@ -408,6 +474,7 @@ function SessionCard({ row }: { row: SessionRow }) {
               sessionId={s.id}
               localDay={latestLocalDay!}
               size="md"
+              agent={s.agent}
             />
           ) : null}
         </div>
@@ -481,3 +548,9 @@ function Stat({ icon, label }: { icon: React.ReactNode; label: string }) {
     </span>
   );
 }
+
+// Registry-driven label — reads displayName off the agent metadata so
+// new agents auto-show up with their declared name.
+function agentLabel(kind: AgentKind): string {
+  return getAgentMetadata(kind)?.displayName ?? kind;
+}

package/app/apps/web/app/settings/ai-features-form.tsx

@@ -4,11 +4,13 @@ import { useState } from "react";
 type Initial = {
   enabled: boolean;
   autoBackfillLastWeek: boolean;
+  autoBackfillYesterday: boolean;
 };
 
 export function AiFeaturesForm({ initial }: { initial: Initial }) {
   const [enabled, setEnabled] = useState(initial.enabled);
   const [autoBackfillLastWeek, setAutoBackfillLastWeek] = useState(initial.autoBackfillLastWeek);
+  const [autoBackfillYesterday, setAutoBackfillYesterday] = useState(initial.autoBackfillYesterday);
   const [saving, setSaving] = useState(false);
   const [savedMsg, setSavedMsg] = useState<string | null>(null);
 
@@ -20,7 +22,7 @@ export function AiFeaturesForm({ initial }: { initial: Initial }) {
       method: "PUT",
       headers: { "content-type": "application/json" },
       body: JSON.stringify({
-        ai_features: { enabled, autoBackfillLastWeek },
+        ai_features: { enabled, autoBackfillLastWeek, autoBackfillYesterday },
       }),
     });
     setSaving(false);
@@ -34,6 +36,23 @@ export function AiFeaturesForm({ initial }: { initial: Initial }) {
         <span>Enable AI digests and enrichment</span>
       </label>
 
+      <label className={`flex items-start gap-2 ${enabled ? "" : "opacity-50"}`}>
+        <input
+          type="checkbox"
+          checked={autoBackfillYesterday}
+          disabled={!enabled}
+          onChange={e => setAutoBackfillYesterday(e.target.checked)}
+        />
+        <span>
+          Auto-backfill yesterday's digest on daemon start
+          <span className="block text-xs text-gray-500 mt-0.5">
+            Generates yesterday's enriched entries and day digest. Runs once
+            per daemon boot. Without this, yesterday's digest only appears
+            after you load the homepage.
+          </span>
+        </span>
+      </label>
+
       <label className={`flex items-start gap-2 ${enabled ? "" : "opacity-50"}`}>
         <input
           type="checkbox"

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

@@ -16,6 +16,7 @@ export default function SettingsPage() {
         <AiFeaturesForm initial={{
           enabled: s.ai_features.enabled,
           autoBackfillLastWeek: s.ai_features.autoBackfillLastWeek,
+          autoBackfillYesterday: s.ai_features.autoBackfillYesterday,
         }} />
       </section>
     </main>