fleetlens 0.6.4 → 0.7.1

package/app/apps/web/components/sidebar.tsx

@@ -21,6 +21,7 @@ import {
 import { formatRelative, prettyProjectName } from "@/lib/format";
 import { ThemeToggle } from "@/components/theme-toggle";
 import { UsageSidebar } from "@/components/usage-sidebar";
+import { ChangelogIcon } from "@/components/changelog-icon";
 import type { UsageSnapshot } from "@/lib/usage-data";
 
 export type ProjectRef = {
@@ -59,11 +60,13 @@ export function Sidebar({
   totalSessions,
   currentUsage,
   version,
+  latestChangelogVersion,
 }: {
   projects: ProjectRef[];
   totalSessions: number;
   currentUsage: UsageSnapshot | null;
   version: string;
+  latestChangelogVersion: string | null;
 }) {
   const pathname = usePathname();
   const [pins, setPins] = useState<Set<string>>(new Set());
@@ -156,7 +159,7 @@ export function Sidebar({
               </span>
             </div>
             <div style={{ fontSize: 11, color: "var(--af-text-tertiary)" }}>
-              Claude Code fleet analytics
+              Multi-agent fleet analytics
             </div>
           </div>
         </div>
@@ -283,6 +286,10 @@ export function Sidebar({
         <span style={{ flex: 1, minWidth: 0 }}>
           {totalSessions} sessions · {projects.length} projects
         </span>
+        <ChangelogIcon
+          latestVersion={latestChangelogVersion}
+          active={pathname === "/changelog"}
+        />
         <Link
           href="/settings"
           aria-label="Settings"

package/app/apps/web/components/week-digest.tsx

@@ -6,6 +6,7 @@ import { Check, Copy } from "lucide-react";
 import type { WeekDigest as WeekDigestType, DayHelpfulness, WeekTopSession, SessionPin } from "@claude-lens/entries";
 import { renderWithFlagChips } from "./flag-chip";
 import { GoalBar } from "./goal-bar";
+import { AgentBadge } from "./agent-badge";
 
 const HELP_COLORS: Record<NonNullable<DayHelpfulness>, string> = {
   essential: "#48bb78",
@@ -1742,6 +1743,7 @@ function TopSessionCard({ session }: { session: WeekTopSession }) {
           >
             {session.project_display}
           </Link>
+          <AgentBadge agent={session.agent} />
           <Link
             href={`/digest/${session.date}`}
             style={{

package/app/apps/web/lib/ai/session-summary.ts

@@ -1,6 +1,6 @@
 /**
  * Compact text summary of a parsed session, suitable as context for
- * the Ask Claude feature. Target: well under 8k tokens so Haiku has
+ * the Ask feature. Target: well under 8k tokens so Haiku has
  * room for an answer.
  *
  * Shape:

package/app/apps/web/lib/calibration-data.ts

@@ -47,70 +47,10 @@ export type PredictedSeriesByKey = {
   seven_day_sonnet: { capturedAt: number; util: number }[];
 };
 
-// History of recent cycles for trend visuals. Each entry is one full cycle
-// the user lived through — `current: true` flags the live (in-progress)
-// cycle, the rest are completed. `source: "real"` = daemon observed the
-// peak, `source: "predicted"` = cycle predates daemon data and we fall
-// back to the JSONL-derived prediction (cold-start path).
-export type CyclePeak = {
-  endsAt: string;
-  peakPct: number;
-  source: "real" | "predicted";
-  current: boolean;
-};
-
-// Per-cycle peak history for a single window (5h or 7d). Used by the
-// dashboard's "previous cycles" trend strip — humans understand "last 4
-// weeks: 86%, 92%, 44%, 34% (current)" much better than a single number.
-// Limited to the last `maxCycles` (most recent) so the visual stays compact.
-export function previousCyclesTrend(
-  dump: CalibrationDump | null,
-  window: "5h" | "7d",
-  maxCycles = 6,
-): CyclePeak[] {
-  if (!dump || dump.curve.length < 2) return [];
-  const HOUR = 3_600_000;
-  const cycleKey: "cycle_end_5h" | "cycle_end_7d" = window === "5h" ? "cycle_end_5h" : "cycle_end_7d";
-  const predKey: "pred_5h" | "pred_7d" = window === "5h" ? "pred_5h" : "pred_7d";
-  const realKey: "real_5h" | "real_7d" = window === "5h" ? "real_5h" : "real_7d";
-
-  // Hour-round the cycle key so millisecond-jittered resets collapse.
-  const byCycle = new Map<number, typeof dump.curve>();
-  for (const p of dump.curve) {
-    const k = p[cycleKey];
-    if (!k) continue;
-    const ms = Date.parse(k);
-    if (Number.isNaN(ms)) continue;
-    const bucket = Math.round(ms / HOUR) * HOUR;
-    const arr = byCycle.get(bucket) ?? [];
-    arr.push(p);
-    byCycle.set(bucket, arr);
-  }
-
-  const nowMs = Date.now();
-  const cycles: CyclePeak[] = [];
-  for (const [endMs, points] of Array.from(byCycle.entries()).sort((a, b) => a[0] - b[0])) {
-    // Take the max across BOTH real and predicted — when the daemon goes
-    // dark before cycle close, predicted forward-extrapolation often
-    // exceeds the last observed value, and the cycle's true peak is the
-    // predicted close, not the last poll. `source` reflects which side won.
-    let peak = 0;
-    let source: "real" | "predicted" = "predicted";
-    for (const p of points) {
-      const r = p[realKey];
-      if (typeof r === "number" && r > peak) { peak = r; source = "real"; }
-      const v = p[predKey] ?? 0;
-      if (v > peak) { peak = v; source = "predicted"; }
-    }
-    cycles.push({
-      endsAt: new Date(endMs).toISOString(),
-      peakPct: Math.round(peak * 10) / 10,
-      source,
-      current: endMs > nowMs,
-    });
-  }
-  return cycles.slice(-maxCycles);
-}
+// Re-export the pure cycle-peak helpers so existing call sites keep
+// working. New tests import directly from ./cycle-peaks (no server-only).
+export { previousCyclesTrend } from "./cycle-peaks";
+export type { CyclePeak } from "./cycle-peaks";
 
 // Converts the calibration dump into the same shape UsageChart expects to
 // overlay on each burndown plot. seven_day_sonnet has no predictor today

package/app/apps/web/lib/changelog-data.generated.ts

@@ -0,0 +1,3 @@
+// AUTOGENERATED by scripts/build-changelog.mjs from CHANGELOG.md.
+// Do not edit by hand — run `pnpm changelog:sync`.
+export const RAW_CHANGELOG = "# Changelog\n\nAll notable user-facing changes to the Fleetlens CLI (`fleetlens` on npm) are\nrecorded here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).\nThe team-server has its own log at `packages/team-server/CHANGELOG.md`.\n\n## [0.7.1] — 2026-05-07\n\n### Fixed\n- Cycle-peaks trend no longer renders two bars labeled the same day. When Anthropic's rolling 7-day window slid its anchor between consecutive polls, the daemon's bucketer (hour-rounded) recorded both reset boundaries as distinct cycles. They're now merged within a 12 h tolerance — same fix in `apps/web/lib/cycle-peaks.ts` (used by `/usage`) and in `packages/cli/src/team/sync.ts` (the daemon's team-server push), so both the personal `/usage` chart and the team-server's plan-utilization view stay consistent. 5-hour cycles keep no merge tolerance (their anchor is stable; merging would collapse legitimate distinct cycles).\n\n## [0.6.4] — 2026-05-04\n\n### Fixed\n- Cached calibration events per-file so `/usage` warm renders complete in well under a second on large session histories.\n\n## [0.6.3] — 2026-05-04\n\n### Fixed\n- Dropped poisoned auto-week locks left behind by interrupted runs; backfill now gates on the live pipeline lock instead.\n\n## [0.6.2] — 2026-05-04\n\n### Added\n- Last week's digest auto-generates on launch when AI features are on. Disable in Settings → AI features.\n\n## [0.6.1] — 2026-05-04\n\n### Changed\n- Smaller install size — published bundle no longer drags in unused workspace metadata.\n\n## [0.6.0] — 2026-04-30\n\n### Added\n- V2 perception layer. Daily, weekly, and monthly digests synthesized from per-session entries via a strict hierarchical pipeline (entry → day → week → month). Past-period digests are immutable on disk; current-period digests use a 10-min in-memory TTL.\n- `/insights` route with on-demand week and month digest generation, picker history, and force-regen.\n- `fleetlens digest day | week | month [--json]` — CLI surface that reproduces the same digests served at `/insights`.\n- `fleetlens entries [--day | --session | --all] [--json]` — inspect the per-session entry primitive.\n\n### Changed\n- Renamed \"active time\" to \"agent time\" across the dashboard and CLI for clarity.\n\n## [0.4.1] — 2026-04-23\n\n### Added\n- Concurrency view on `/parallelism` page. Bursts colored teal for same-project and purple for cross-project (the genuinely interesting fleet-work signal).\n- Plan utilization sparkline on the sidebar, fed by the usage daemon's 5-min snapshots.\n\n### Fixed\n- Auto-update no longer leaves a zombie web server on the old binary; both server and daemon are torn down before re-exec.\n\n## [0.4.0] — 2026-04-18\n\n### Added\n- Usage daemon (`fleetlens daemon …`) polls `/api/oauth/usage` every 5 min and appends snapshots to `~/.cclens/usage.jsonl`. `fleetlens start` and `fleetlens stop` manage server + daemon together.\n- `fleetlens usage --history` for inspecting past plan utilization.\n\n## [0.3.0] — 2026-04-10\n\n### Added\n- Project rollups with worktree aggregation. Sessions inside `<project>/.worktrees/<name>` roll up under their parent canonical project with a `+N wt` badge.\n- Pinned projects in the sidebar (per-browser via localStorage).\n\n## [0.2.0] — 2026-04-01\n\n### Changed\n- Active-segment computation now uses all timestamped events (system + summary + sidechain + conversational) instead of conversational-only. Earlier filter undercounted by up to 100x on tool-heavy sessions.\n\n## [0.1.0] — 2026-03-15\n\n### Added\n- Initial release. Local-only dashboard for Claude Code sessions: timeline, projects, daily activity bucketing, parallelism detection, per-model cost estimation. Reads JSONL transcripts from `~/.claude/projects/`.\n";

package/app/apps/web/lib/changelog.ts

@@ -0,0 +1,67 @@
+import { RAW_CHANGELOG } from "./changelog-data.generated";
+
+export type ChangelogSection = {
+  /** "Added" | "Changed" | "Fixed" | etc. — verbatim from `### <kind>` heading. */
+  kind: string;
+  bullets: string[];
+};
+
+export type ChangelogEntry = {
+  version: string;
+  date: string | null;
+  sections: ChangelogSection[];
+};
+
+export const STORAGE_KEY = "cclens:changelog-last-seen";
+
+const VERSION_HEADING = /^##\s+\[([^\]]+)\](?:\s+[—\-–]\s+(\S+))?\s*$/;
+const SECTION_HEADING = /^###\s+(.+?)\s*$/;
+const BULLET = /^[-*]\s+(.+?)\s*$/;
+
+export function parseChangelog(raw: string): ChangelogEntry[] {
+  const lines = raw.split(/\r?\n/);
+  const entries: ChangelogEntry[] = [];
+  let current: ChangelogEntry | null = null;
+  let section: ChangelogSection | null = null;
+  let bulletBuf: string[] = [];
+
+  function flushBullet(): void {
+    if (section && bulletBuf.length > 0) {
+      section.bullets.push(bulletBuf.join(" ").trim());
+      bulletBuf = [];
+    }
+  }
+
+  for (const line of lines) {
+    const v = VERSION_HEADING.exec(line);
+    if (v) {
+      flushBullet();
+      section = null;
+      current = { version: v[1].trim(), date: v[2]?.trim() ?? null, sections: [] };
+      entries.push(current);
+      continue;
+    }
+    if (!current) continue;
+    const s = SECTION_HEADING.exec(line);
+    if (s) {
+      flushBullet();
+      section = { kind: s[1].trim(), bullets: [] };
+      current.sections.push(section);
+      continue;
+    }
+    const b = BULLET.exec(line);
+    if (b) {
+      flushBullet();
+      bulletBuf = [b[1]];
+      continue;
+    }
+    if (bulletBuf.length > 0 && line.trim().length > 0) {
+      bulletBuf.push(line.trim());
+    }
+  }
+  flushBullet();
+  return entries;
+}
+
+export const ENTRIES: ChangelogEntry[] = parseChangelog(RAW_CHANGELOG);
+export const LATEST_VERSION: string | null = ENTRIES[0]?.version ?? null;

package/app/apps/web/lib/cycle-peaks.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect } from "vitest";
+import {
+  previousCyclesTrend,
+  type CalibrationCurvePoint,
+  type CalibrationLike,
+} from "./cycle-peaks";
+
+function dump(curve: CalibrationCurvePoint[]): CalibrationLike {
+  return { curve };
+}
+
+function point(overrides: Partial<CalibrationCurvePoint>): CalibrationCurvePoint {
+  return {
+    ts: "2026-05-01T00:00:00.000Z",
+    real_5h: null,
+    pred_5h: 0,
+    real_7d: null,
+    pred_7d: 0,
+    cycle_end_5h: null,
+    cycle_end_7d: null,
+    ...overrides,
+  };
+}
+
+const NOW = Date.parse("2026-05-08T00:00:00.000Z");
+
+describe("previousCyclesTrend (7d)", () => {
+  it("merges two cycle ends within 12 h into a single cycle, latest endsAt + max peak", () => {
+    // Regression: Anthropic's rolling 7-day window slid its anchor between
+    // two polls on the same day, producing two distinct hour-buckets.
+    // Without the merge, /usage and the team-server both rendered two
+    // bars labeled the same day.
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: "2026-05-07T07:00:00.000Z", real_7d: 6 }),
+        point({ cycle_end_7d: "2026-05-07T09:00:00.000Z", real_7d: 91 }),
+      ]),
+      "7d",
+      6,
+      NOW,
+    );
+    expect(result).toHaveLength(1);
+    expect(result[0].endsAt).toBe("2026-05-07T09:00:00.000Z");
+    expect(result[0].peakPct).toBe(91);
+    expect(result[0].source).toBe("real");
+  });
+
+  it("keeps cycles 7 d apart as distinct entries", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: "2026-04-30T12:00:00.000Z", real_7d: 50 }),
+        point({ cycle_end_7d: "2026-05-07T12:00:00.000Z", real_7d: 80 }),
+      ]),
+      "7d",
+      6,
+      NOW,
+    );
+    expect(result).toHaveLength(2);
+    expect(result.map((r) => r.endsAt)).toEqual([
+      "2026-04-30T12:00:00.000Z",
+      "2026-05-07T12:00:00.000Z",
+    ]);
+  });
+
+  it("collapses millisecond-jitter on the same reset boundary", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: "2026-05-07T12:00:00.123Z", real_7d: 40 }),
+        point({ cycle_end_7d: "2026-05-07T12:00:00.999Z", real_7d: 60 }),
+      ]),
+      "7d",
+      6,
+      NOW,
+    );
+    expect(result).toHaveLength(1);
+    expect(result[0].peakPct).toBe(60);
+  });
+
+  it("takes max across real AND predicted, preferring real when it wins", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: "2026-05-07T12:00:00.000Z", real_7d: 30, pred_7d: 20 }),
+        point({ cycle_end_7d: "2026-05-07T12:00:00.000Z", real_7d: 50, pred_7d: 40 }),
+      ]),
+      "7d",
+      6,
+      NOW,
+    );
+    expect(result[0].peakPct).toBe(50);
+    expect(result[0].source).toBe("real");
+  });
+
+  it("falls back to predicted when no real value is recorded", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: "2026-05-07T12:00:00.000Z", pred_7d: 70 }),
+        point({ cycle_end_7d: "2026-05-07T12:00:00.000Z", pred_7d: 40 }),
+      ]),
+      "7d",
+      6,
+      NOW,
+    );
+    expect(result[0].peakPct).toBe(70);
+    expect(result[0].source).toBe("predicted");
+  });
+
+  it("respects maxCycles by returning the most recent N", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: "2026-04-02T00:00:00.000Z", real_7d: 10 }),
+        point({ cycle_end_7d: "2026-04-09T00:00:00.000Z", real_7d: 20 }),
+        point({ cycle_end_7d: "2026-04-16T00:00:00.000Z", real_7d: 0.3 }),
+        point({ cycle_end_7d: "2026-04-23T00:00:00.000Z", real_7d: 40 }),
+      ]),
+      "7d",
+      2,
+      NOW,
+    );
+    expect(result).toHaveLength(2);
+    expect(result.map((r) => r.endsAt)).toEqual([
+      "2026-04-16T00:00:00.000Z",
+      "2026-04-23T00:00:00.000Z",
+    ]);
+  });
+
+  it("flags the future-ending cycle as current", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: "2026-05-01T00:00:00.000Z", real_7d: 50 }),
+        point({ cycle_end_7d: "2026-05-09T00:00:00.000Z", real_7d: 0.7 }),
+      ]),
+      "7d",
+      6,
+      NOW,
+    );
+    expect(result.find((r) => r.endsAt.startsWith("2026-05-01"))?.current).toBe(false);
+    expect(result.find((r) => r.endsAt.startsWith("2026-05-09"))?.current).toBe(true);
+  });
+
+  it("returns empty when the dump is null or has fewer than two points", () => {
+    expect(previousCyclesTrend(null, "7d", 6, NOW)).toEqual([]);
+    expect(
+      previousCyclesTrend(
+        dump([point({ cycle_end_7d: "2026-05-07T12:00:00.000Z" })]),
+        "7d",
+        6,
+        NOW,
+      ),
+    ).toEqual([]);
+  });
+
+  it("skips points missing the cycle key", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_7d: null, real_7d: 50 }),
+        point({ cycle_end_7d: "2026-05-07T12:00:00.000Z", real_7d: 40 }),
+      ]),
+      "7d",
+      6,
+      NOW,
+    );
+    expect(result).toHaveLength(1);
+    expect(result[0].peakPct).toBe(40);
+  });
+});
+
+describe("previousCyclesTrend (5h)", () => {
+  it("keeps two 5h cycle ends as distinct entries (no merge tolerance for 5h)", () => {
+    const result = previousCyclesTrend(
+      dump([
+        point({ cycle_end_5h: "2026-05-07T10:00:00.000Z", real_5h: 30 }),
+        point({ cycle_end_5h: "2026-05-07T15:00:00.000Z", real_5h: 70 }),
+      ]),
+      "5h",
+      6,
+      NOW,
+    );
+    expect(result).toHaveLength(2);
+    expect(result.map((r) => r.endsAt)).toEqual([
+      "2026-05-07T10:00:00.000Z",
+      "2026-05-07T15:00:00.000Z",
+    ]);
+    expect(result.map((r) => r.peakPct)).toEqual([30, 70]);
+  });
+});

package/app/apps/web/lib/cycle-peaks.ts

@@ -0,0 +1,104 @@
+// Pure helpers for deriving per-cycle peak utilization from the daemon's
+// calibration curve. Lives separately from calibration-data.ts so it can
+// be imported in unit tests (calibration-data.ts pulls in `server-only`
+// for its fs-touching helpers).
+
+export type CalibrationCurvePoint = {
+  ts: string;
+  real_5h: number | null;
+  pred_5h: number;
+  real_7d: number | null;
+  pred_7d: number;
+  cycle_end_5h?: string | null;
+  cycle_end_7d?: string | null;
+};
+
+export type CalibrationLike = {
+  curve: CalibrationCurvePoint[];
+};
+
+export type CyclePeak = {
+  endsAt: string;
+  peakPct: number;
+  source: "real" | "predicted";
+  current: boolean;
+};
+
+const HOUR = 3_600_000;
+
+/** History of recent cycles for trend visuals. Each entry is one full
+ *  cycle — `current: true` for the in-progress cycle, completed otherwise.
+ *  Limited to the last `maxCycles` so the visual stays compact. */
+export function previousCyclesTrend(
+  dump: CalibrationLike | null,
+  window: "5h" | "7d",
+  maxCycles = 6,
+  nowMs: number = Date.now(),
+): CyclePeak[] {
+  if (!dump || dump.curve.length < 2) return [];
+  const cycleKey: "cycle_end_5h" | "cycle_end_7d" = window === "5h" ? "cycle_end_5h" : "cycle_end_7d";
+  const predKey: "pred_5h" | "pred_7d" = window === "5h" ? "pred_5h" : "pred_7d";
+  const realKey: "real_5h" | "real_7d" = window === "5h" ? "real_5h" : "real_7d";
+
+  // Hour-round the cycle key so millisecond-jittered resets collapse, then
+  // merge adjacent buckets within a window-specific tolerance. Anthropic's
+  // rolling 7-day window can slide its anchor by a few hours within the
+  // SAME cycle (different polls report different `seven_day.resets_at`
+  // values); without this merge, a cycle that slid would render as two
+  // bars labeled the same day. The 5-hour cycle's anchor is stable, so we
+  // don't merge there beyond hour-rounding — distinct 5h cycles would
+  // otherwise collapse.
+  const TOLERANCE_MS = window === "7d" ? 12 * HOUR : 0;
+  const byCycle = new Map<number, CalibrationCurvePoint[]>();
+  for (const p of dump.curve) {
+    const k = p[cycleKey];
+    if (!k) continue;
+    const ms = Date.parse(k);
+    if (Number.isNaN(ms)) continue;
+    const bucket = Math.round(ms / HOUR) * HOUR;
+    const arr = byCycle.get(bucket) ?? [];
+    arr.push(p);
+    byCycle.set(bucket, arr);
+  }
+  const merged = mergeAdjacentBuckets(byCycle, TOLERANCE_MS);
+
+  const cycles: CyclePeak[] = [];
+  for (const { endMs, points } of merged) {
+    let peak = 0;
+    let source: "real" | "predicted" = "predicted";
+    for (const p of points) {
+      const r = p[realKey];
+      if (typeof r === "number" && r > peak) { peak = r; source = "real"; }
+      const v = p[predKey] ?? 0;
+      if (v > peak) { peak = v; source = "predicted"; }
+    }
+    cycles.push({
+      endsAt: new Date(endMs).toISOString(),
+      peakPct: Math.round(peak * 10) / 10,
+      source,
+      current: endMs > nowMs,
+    });
+  }
+  return cycles.slice(-maxCycles);
+}
+
+/** Merge buckets whose end-times are within `toleranceMs` of each other.
+ *  Output sorted ascending by `endMs`. Each merged bucket adopts the
+ *  LATEST endMs (so the rendered label reflects the most recent reset
+ *  boundary) and the union of points from all merged buckets. */
+export function mergeAdjacentBuckets<P>(
+  byCycle: Map<number, P[]>,
+  toleranceMs: number,
+): Array<{ endMs: number; points: P[] }> {
+  const merged: Array<{ endMs: number; points: P[] }> = [];
+  for (const [endMs, points] of Array.from(byCycle.entries()).sort((a, b) => a[0] - b[0])) {
+    const last = merged[merged.length - 1];
+    if (last && endMs - last.endMs <= toleranceMs) {
+      last.endMs = endMs;
+      last.points.push(...points);
+    } else {
+      merged.push({ endMs, points: [...points] });
+    }
+  }
+  return merged;
+}

package/app/apps/web/lib/data.ts

@@ -1,21 +1,20 @@
 /**
  * Server-only data access layer.
  *
- * Wraps @claude-lens/parser/fs with a per-request cache so that a
- * single RSC render doesn't re-scan ~/.claude/projects for every page
- * component that needs the session list.
+ * Wraps @claude-lens/parser/fs with a per-request cache so a single RSC
+ * render doesn't re-scan the agent disk roots for every page that needs
+ * the session list. Multi-agent: iterates the parser's AgentSource
+ * registry, so adding a new agent means adding one source — no edits here.
  */
 
 import "server-only";
 import { cache } from "react";
-import { listSessions as rawListSessions, getSession as rawGetSession } from "@claude-lens/parser/fs";
-
-const dataRoot = process.env.CCLENS_DATA_DIR || undefined;
+import { listAllSessions, getAnySession } from "@claude-lens/parser/fs";
 
 export const listSessions = cache(async () => {
-  return rawListSessions({ limit: 1000, root: dataRoot });
+  return listAllSessions({ limit: 1000 });
 });
 
 export const getSession = cache(async (id: string) => {
-  return rawGetSession(id, { root: dataRoot });
+  return getAnySession(id);
 });

package/app/apps/web/lib/date-range.ts

@@ -7,11 +7,18 @@
 
 export type RangeKey = "7d" | "30d" | "90d" | "all";
 
-/** Parse a search-param value into a RangeKey (default: "all"). */
+/**
+ * Parse a search-param value into a RangeKey (default: "90d").
+ *
+ * 90d is chosen as a sensible recent window for the heatmap and activity
+ * chart — large enough to show trends, small enough that one stale agent
+ * (Codex sessions back to last September, say) doesn't stretch the x-axis
+ * across months of empty days. Users can still pick "all" explicitly.
+ */
 export function parseRange(value: string | string[] | undefined): RangeKey {
   const v = Array.isArray(value) ? value[0] : value;
   if (v === "7d" || v === "30d" || v === "90d" || v === "all") return v;
-  return "all";
+  return "90d";
 }
 
 /**

package/app/apps/web/lib/usage-data.ts

@@ -9,6 +9,7 @@ import { cache } from "react";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
+import type { AgentKind } from "@claude-lens/parser";
 
 export type UsageWindow = {
   utilization: number | null;
@@ -17,6 +18,9 @@ export type UsageWindow = {
 
 export type UsageSnapshot = {
   captured_at: string;
+  /** Source agent. Absent on legacy snapshots written before multi-agent
+   *  support — readers MUST treat undefined as "claude-code". */
+  agent?: AgentKind;
   five_hour: UsageWindow;
   seven_day: UsageWindow;
   seven_day_opus: UsageWindow | null;
@@ -29,6 +33,7 @@ export type UsageSnapshot = {
     used_credits: number | null;
     utilization: number | null;
   } | null;
+  plan_type?: string | null;
 };
 
 function usageLogPath(): string {
@@ -53,9 +58,27 @@ export const readUsageSnapshots = cache((): UsageSnapshot[] => {
 
 export const latestUsageSnapshot = cache((): UsageSnapshot | null => {
   const all = readUsageSnapshots();
-  return all.length > 0 ? all[all.length - 1]! : null;
+  // Sidebar's "current usage" widget is Claude-tier specific (extra_usage,
+  // per-model 7d windows). Filter to Claude only so a Codex snapshot doesn't
+  // accidentally end up as the latest source.
+  const claude = all.filter((s) => (s.agent ?? "claude-code") === "claude-code");
+  return claude.length > 0 ? claude[claude.length - 1]! : null;
 });
 
+export const latestUsageSnapshotByAgent = cache(
+  (agent: AgentKind): UsageSnapshot | null => {
+    const all = readUsageSnapshots();
+    const filtered = all.filter((s) => (s.agent ?? "claude-code") === agent);
+    return filtered.length > 0 ? filtered[filtered.length - 1]! : null;
+  },
+);
+
+export const readUsageSnapshotsByAgent = cache(
+  (agent: AgentKind): UsageSnapshot[] => {
+    return readUsageSnapshots().filter((s) => (s.agent ?? "claude-code") === agent);
+  },
+);
+
 // The CLI's profile cache mirrors what we report to a paired team-server.
 // Reading it here keeps personal and team editions consistent — both show
 // the same "what tier are we?" answer.

package/app/apps/web/lib/validate-settings.ts

@@ -4,6 +4,7 @@ export const SettingsUpdateSchema = z.object({
   ai_features: z.object({
     enabled: z.boolean().optional(),
     autoBackfillLastWeek: z.boolean().optional(),
+    autoBackfillYesterday: z.boolean().optional(),
   }).refine((v) => Object.keys(v).length > 0, {
     message: "ai_features must include at least one field",
   }),

package/app/apps/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@claude-lens/web",
-  "version": "0.6.4",
+  "version": "0.7.1",
   "private": true,
   "description": "Local-only dashboard for Claude Code sessions. Reads ~/.claude/projects/*.jsonl and visualizes agent activity.",
   "license": "MIT",