fleetlens 0.4.0 → 0.6.0

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

@@ -0,0 +1,266 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync, openSync, readSync, closeSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/**
+ * GET /api/runs?since=24h
+ *
+ * Mirrors `fleetlens runs --json`. Returns a snapshot of currently-running
+ * LLM subprocesses (week_digest / top_session / day_digest / entry_enrich)
+ * plus aggregated token spend in the requested window.
+ */
+
+const KIND_MARKERS: Array<{ kind: string; marker: RegExp }> = [
+  { kind: "week_digest",  marker: /weekly retrospective writer/i },
+  { kind: "top_session",  marker: /editorial perception layer for ONE session/i },
+  { kind: "day_digest",   marker: /single local day into a short, honest narrative/i },
+  { kind: "entry_enrich", marker: /per[- ]entry|enrich.{0,40}entry|brief_summary/i },
+];
+
+function detectKind(cmdline: string): string {
+  for (const { kind, marker } of KIND_MARKERS) {
+    if (marker.test(cmdline)) return kind;
+  }
+  return "unknown";
+}
+
+function parseModel(cmdline: string): string {
+  const m = cmdline.match(/--model\s+(\S+)/);
+  return m ? m[1]! : "?";
+}
+
+type ActiveRun = {
+  pid: number;
+  kind: string;
+  model: string;
+  elapsed_s: number;
+  cpu_time: string;
+};
+
+function etimeToSec(s: string): number {
+  const m = s.match(/^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+)$/);
+  if (!m) return 0;
+  const [, dStr, hStr, mStr, secStr] = m;
+  return Number(dStr ?? 0) * 86400 + Number(hStr ?? 0) * 3600 + Number(mStr ?? 0) * 60 + Number(secStr ?? 0);
+}
+
+function listActiveRuns(): ActiveRun[] {
+  let out: string;
+  try {
+    out = execSync("ps -axww -o pid,etime,time,command", { encoding: "utf-8" });
+  } catch {
+    return [];
+  }
+  const runs: ActiveRun[] = [];
+  for (const line of out.split("\n")) {
+    if (!line.includes("claude -p")) continue;
+    if (!line.includes("--append-system-prompt")) continue;
+    if (line.includes("grep")) continue;
+    const m = line.trim().match(/^(\d+)\s+(\S+)\s+([\d:.]+)\s+(.+)$/);
+    if (!m) continue;
+    const [, pidStr, etimeStr, cputime, command] = m;
+    runs.push({
+      pid: Number(pidStr),
+      kind: detectKind(command!),
+      model: parseModel(command!),
+      elapsed_s: etimeToSec(etimeStr!),
+      cpu_time: cputime!,
+    });
+  }
+  return runs.sort((a, b) => a.elapsed_s - b.elapsed_s);
+}
+
+const SPEND_PATH = join(homedir(), ".cclens", "llm-spend.jsonl");
+
+type CompletedRun = {
+  ts: string;
+  kind: string;
+  ref: string;
+  model: string;
+  input_tokens: number;
+  output_tokens: number;
+  cost_usd: number;
+};
+
+function readSpend(sinceMs: number): CompletedRun[] {
+  if (!existsSync(SPEND_PATH)) return [];
+  const lines = readFileSync(SPEND_PATH, "utf-8").split("\n").filter(l => l.trim());
+  const out: CompletedRun[] = [];
+  for (const line of lines) {
+    try {
+      const r = JSON.parse(line);
+      const ts = Date.parse(r.ts);
+      if (Number.isNaN(ts) || ts < sinceMs) continue;
+      out.push({
+        ts: r.ts,
+        kind: r.kind ?? "?",
+        ref: r.ref ?? "",
+        model: r.model ?? "?",
+        input_tokens: r.input_tokens ?? 0,
+        output_tokens: r.output_tokens ?? 0,
+        cost_usd: r.cost_usd ?? 0,
+      });
+    } catch { /* skip */ }
+  }
+  return out;
+}
+
+function parseSince(s: string | null): number {
+  if (!s) return Date.now() - 24 * 3_600_000;
+  const m = s.match(/^(\d+)([smhd])$/);
+  if (m) {
+    const n = Number(m[1]);
+    const unit = m[2];
+    const mult = unit === "s" ? 1000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+    return Date.now() - n * mult;
+  }
+  const t = Date.parse(s);
+  if (!Number.isNaN(t)) return t;
+  return Date.now() - 24 * 3_600_000;
+}
+
+const RUNS_DIR = join(homedir(), ".cclens", "llm-runs");
+
+type TraceSummary = {
+  run_id: string;
+  kind: string;
+  model: string;
+  pid: number | null;
+  started_at: string;
+  ended_at: string | null;
+  elapsed_ms: number | null;
+  exit_code: number | null;
+  status: "running" | "ok" | "error" | "unknown";
+  content_chars: number | null;
+  output_tokens: number | null;
+};
+
+function listRecentTraces(limit: number): TraceSummary[] {
+  if (!existsSync(RUNS_DIR)) return [];
+  const files = readdirSync(RUNS_DIR)
+    .filter(f => f.endsWith(".jsonl"))
+    .map(f => ({ id: f.replace(/\.jsonl$/, ""), path: join(RUNS_DIR, f), mtime: statSync(join(RUNS_DIR, f)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime)
+    .slice(0, limit);
+
+  const out: TraceSummary[] = [];
+  for (const f of files) {
+    let start: { ts?: string; kind?: string; model?: string } | null = null;
+    let spawned: { pid?: number } | null = null;
+    let end: { ts?: string; elapsed_ms?: number; exit_code?: number; content_chars?: number; output_tokens?: number } | null = null;
+    let spawnError: { ts?: string } | null = null;
+
+    try {
+      // Read first ~16KB (start + spawned + maybe payload) and last ~4KB (end record)
+      const stat = statSync(f.path);
+      const headSize = Math.min(16_384, stat.size);
+      const tailSize = Math.min(4_096, stat.size);
+      const buf = Buffer.alloc(headSize);
+      const fd = openSync(f.path, "r");
+      try {
+        readSync(fd, buf, 0, headSize, 0);
+      } finally {
+        closeSync(fd);
+      }
+      const head = buf.toString("utf-8");
+      // Parse every _meta record visible in head — start, spawned, AND end /
+      // spawn_error. Previously end/spawn_error were only checked in the tail
+      // block, which got skipped when the file fit entirely in headSize. That
+      // left small completed traces (~10-15KB entry-enrich files) stuck at
+      // status="running" forever, even though their end record was already in
+      // the head buffer.
+      for (const line of head.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line) as { _meta?: { type?: string; ts?: string; kind?: string; model?: string; pid?: number; elapsed_ms?: number; exit_code?: number; content_chars?: number; output_tokens?: number } };
+          const t = obj._meta?.type;
+          if (t === "start") start = obj._meta!;
+          else if (t === "spawned") spawned = obj._meta!;
+          else if (t === "end") end = obj._meta!;
+          else if (t === "spawn_error") spawnError = obj._meta!;
+        } catch { /* skip */ }
+      }
+
+      if (!end && !spawnError && stat.size > headSize) {
+        const tailBuf = Buffer.alloc(tailSize);
+        const fd2 = openSync(f.path, "r");
+        try {
+          readSync(fd2, tailBuf, 0, tailSize, stat.size - tailSize);
+        } finally {
+          closeSync(fd2);
+        }
+        const tail = tailBuf.toString("utf-8");
+        for (const line of tail.split("\n").reverse()) {
+          if (!line.trim()) continue;
+          try {
+            const obj = JSON.parse(line) as { _meta?: { type?: string; ts?: string; elapsed_ms?: number; exit_code?: number; content_chars?: number; output_tokens?: number } };
+            if (obj._meta?.type === "end") { end = obj._meta; break; }
+            if (obj._meta?.type === "spawn_error") { spawnError = obj._meta; break; }
+          } catch { /* skip */ }
+        }
+      }
+    } catch { /* skip */ }
+
+    const status: TraceSummary["status"] =
+      end ? (end.exit_code === 0 ? "ok" : "error")
+        : spawnError ? "error"
+          : start ? "running"
+            : "unknown";
+
+    out.push({
+      run_id: f.id,
+      kind: start?.kind ?? "?",
+      model: start?.model ?? "?",
+      pid: spawned?.pid ?? null,
+      started_at: start?.ts ?? "",
+      ended_at: end?.ts ?? null,
+      elapsed_ms: end?.elapsed_ms ?? null,
+      exit_code: end?.exit_code ?? null,
+      status,
+      content_chars: end?.content_chars ?? null,
+      output_tokens: end?.output_tokens ?? null,
+    });
+  }
+  return out;
+}
+
+export async function GET(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const sinceMs = parseSince(url.searchParams.get("since"));
+  const traceLimit = Number(url.searchParams.get("trace_limit") ?? "30");
+  const active = listActiveRuns();
+  const completed = readSpend(sinceMs);
+  const traces = listRecentTraces(traceLimit);
+
+  type Totals = { ops: number; input_tokens: number; output_tokens: number; cost_usd: number };
+  const totals: Totals = { ops: completed.length, input_tokens: 0, output_tokens: 0, cost_usd: 0 };
+  const byKind: Record<string, Totals> = {};
+  for (const r of completed) {
+    totals.input_tokens += r.input_tokens;
+    totals.output_tokens += r.output_tokens;
+    totals.cost_usd += r.cost_usd;
+    const k = byKind[r.kind] ?? { ops: 0, input_tokens: 0, output_tokens: 0, cost_usd: 0 };
+    k.ops += 1;
+    k.input_tokens += r.input_tokens;
+    k.output_tokens += r.output_tokens;
+    k.cost_usd += r.cost_usd;
+    byKind[r.kind] = k;
+  }
+
+  return new Response(JSON.stringify({
+    generated_at: new Date().toISOString(),
+    active,
+    completed_since_ms: sinceMs,
+    totals,
+    by_kind: byKind,
+    completed,
+    traces,
+  }, null, 2), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}

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

@@ -0,0 +1,35 @@
+import { NextResponse } from "next/server";
+import { readSettings, writeSettings, monthToDateSpend } from "@claude-lens/entries/node";
+import { SettingsUpdateSchema } from "@/lib/validate-settings";
+
+export const runtime = "nodejs";
+
+export async function GET() {
+  return NextResponse.json({
+    settings: readSettings(),
+    month_to_date_spend_usd: monthToDateSpend(),
+  });
+}
+
+export async function PUT(req: Request) {
+  let raw: unknown;
+  try {
+    raw = await req.json();
+  } catch {
+    return NextResponse.json({ error: "invalid JSON body" }, { status: 400 });
+  }
+  const parsed = SettingsUpdateSchema.safeParse(raw);
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: "schema validation failed", issues: parsed.error.issues },
+      { status: 400 },
+    );
+  }
+  // Preserve other on-disk fields (model, monthlyBudgetUsd) — UI no longer edits
+  // them, but the settings module and queue still read them. Only enabled flips.
+  const current = readSettings();
+  writeSettings({
+    ai_features: { ...current.ai_features, enabled: parsed.data.ai_features.enabled },
+  });
+  return NextResponse.json({ ok: true });
+}

package/app/apps/web/app/day/[date]/day-view.tsx

@@ -0,0 +1,193 @@
+"use client";
+
+import { useState } from "react";
+import { ChevronDown, ChevronRight, Layers } from "lucide-react";
+import type { DayDigest, Entry } from "@claude-lens/entries";
+import type { GanttDay, ParallelismBurst } from "@claude-lens/parser";
+import { DayDigestView } from "@/components/day-digest-view";
+import { GanttChart, type SessionEntrySummary } from "../../parallelism/gantt-chart";
+import { BackfillDrawer, type BackfillRow } from "@/components/backfill-drawer";
+import { DateNav, type DayInfo } from "@/components/date-nav";
+
+export function DayView({
+  date,
+  today,
+  prev,
+  next,
+  initial,
+  entries,
+  aiEnabled,
+  gantt,
+  bursts,
+  sessionEntries,
+  backfillRows,
+  dayStats,
+}: {
+  date: string;
+  today: string;
+  prev: string;
+  next: string | null;
+  initial: DayDigest | null;
+  entries: Entry[];
+  aiEnabled: boolean;
+  gantt: GanttDay;
+  bursts: ParallelismBurst[];
+  sessionEntries: Record<string, SessionEntrySummary>;
+  backfillRows: BackfillRow[];
+  dayStats: DayInfo[];
+}) {
+  const [drawerOpen, setDrawerOpen] = useState(false);
+  // Narrative section is suppressed when every entry is `skipped_trivial` —
+  // that's a "warm-up only" day with nothing to summarize, so the section
+  // would just be a header above an empty placeholder. Keep the timeline
+  // accessible via its own collapsible.
+  const allTrivial = entries.length > 0
+    && entries.every((e) => e.enrichment.status === "skipped_trivial");
+  const hasNarrative = entries.length > 0 && !allTrivial;
+  const hasTimeline = gantt.sessions.length > 0;
+
+  const fmtDate = new Date(`${date}T12:00:00`).toLocaleDateString("en-US", {
+    weekday: "long", month: "long", day: "numeric", year: "numeric",
+  });
+
+  const pendingCount = backfillRows.filter((r) => r.status === "pending").length;
+
+  return (
+    <>
+      <nav
+        style={{
+          padding: "14px 40px",
+          display: "flex",
+          gap: 12,
+          fontSize: 12,
+          borderBottom: "1px solid var(--af-border-subtle)",
+          alignItems: "center",
+          flexWrap: "wrap",
+        }}
+      >
+        <DateNav
+          date={date}
+          today={today}
+          prevDay={prev}
+          nextDay={next ?? undefined}
+          dayStats={dayStats}
+        />
+
+        <button
+          type="button"
+          onClick={() => setDrawerOpen(true)}
+          style={{
+            marginLeft: "auto",
+            display: "inline-flex",
+            alignItems: "center",
+            gap: 5,
+            padding: "5px 10px",
+            background: "transparent",
+            border: "1px solid var(--af-border-subtle)",
+            borderRadius: 6,
+            fontSize: 11,
+            color: "var(--af-text-secondary)",
+            cursor: "pointer",
+          }}
+          title="Open the backfill multi-select drawer"
+        >
+          <Layers size={12} />
+          Backfill digests
+          {pendingCount > 0 && (
+            <span
+              style={{
+                fontSize: 10,
+                color: "#ed8936",
+                fontWeight: 700,
+              }}
+            >
+              {pendingCount}
+            </span>
+          )}
+        </button>
+      </nav>
+
+      {!hasNarrative && !hasTimeline ? (
+        <div
+          style={{
+            padding: "60px 40px",
+            textAlign: "center",
+            color: "var(--af-text-secondary)",
+          }}
+        >
+          <div style={{ fontSize: 14, marginBottom: 6 }}>{fmtDate}</div>
+          <div style={{ fontSize: 13, color: "var(--af-text-tertiary)" }}>
+            No Claude Code activity on this day.
+          </div>
+        </div>
+      ) : (
+        <div style={{ display: "flex", flexDirection: "column", gap: 0 }}>
+          {hasNarrative && (
+            <Section label="Narrative" defaultOpen>
+              <DayDigestView
+                initial={initial}
+                entries={entries}
+                date={date}
+                aiEnabled={aiEnabled}
+              />
+            </Section>
+          )}
+          {hasTimeline && (
+            <Section label="Timeline & concurrency" defaultOpen>
+              <div style={{ padding: "8px 40px 40px" }}>
+                <GanttChart gantt={gantt} bursts={bursts} sessionEntries={sessionEntries} />
+              </div>
+            </Section>
+          )}
+        </div>
+      )}
+
+      <BackfillDrawer
+        open={drawerOpen}
+        onClose={() => setDrawerOpen(false)}
+        rows={backfillRows}
+        aiEnabled={aiEnabled}
+      />
+    </>
+  );
+}
+
+function Section({
+  label,
+  defaultOpen = true,
+  children,
+}: {
+  label: string;
+  defaultOpen?: boolean;
+  children: React.ReactNode;
+}) {
+  const [open, setOpen] = useState(defaultOpen);
+  return (
+    <div style={{ borderBottom: "1px solid var(--af-border-subtle)" }}>
+      <button
+        type="button"
+        onClick={() => setOpen((v) => !v)}
+        style={{
+          width: "100%",
+          padding: "12px 40px",
+          background: "transparent",
+          border: "none",
+          textAlign: "left",
+          display: "flex",
+          alignItems: "center",
+          gap: 8,
+          cursor: "pointer",
+          fontSize: 11,
+          fontWeight: 700,
+          color: "var(--af-text-tertiary)",
+          textTransform: "uppercase",
+          letterSpacing: "0.08em",
+        }}
+      >
+        {open ? <ChevronDown size={13} /> : <ChevronRight size={13} />}
+        {label}
+      </button>
+      {open && <div>{children}</div>}
+    </div>
+  );
+}

package/app/apps/web/app/day/[date]/page.tsx

@@ -0,0 +1,175 @@
+import { listSessions, getSession } from "@/lib/data";
+import {
+  buildGanttDay,
+  computeParallelismBursts,
+  computeBurstsFromSessions,
+  dailyActivity,
+  type GanttDay,
+  type ParallelismBurst,
+} from "@claude-lens/parser";
+import { toLocalDay as toLocalDayParser } from "@claude-lens/parser";
+import { readDayDigest, listEntriesForDay } from "@claude-lens/entries/fs";
+import { readSettings, buildDeterministicDigest, getTodayDigestFromCache } from "@claude-lens/entries/node";
+import type { DayDigest } from "@claude-lens/entries";
+import { isValidDate, todayLocal, toLocalDay } from "@/lib/entries";
+import { buildEntriesIndex } from "@/lib/entries-index";
+import type { SessionEntrySummary } from "../../parallelism/gantt-chart";
+import type { BackfillRow } from "@/components/backfill-drawer";
+import type { DayInfo } from "@/components/date-nav";
+import { DayView } from "./day-view";
+import Link from "next/link";
+import { notFound } from "next/navigation";
+
+export const dynamic = "force-dynamic";
+
+const BACKFILL_DAYS = 30;
+
+function addDays(date: string, n: number): string {
+  const [y, m, d] = date.split("-").map(Number);
+  const dt = new Date(y!, (m ?? 1) - 1, d, 12);
+  dt.setDate(dt.getDate() + n);
+  return `${dt.getFullYear()}-${String(dt.getMonth() + 1).padStart(2, "0")}-${String(dt.getDate()).padStart(2, "0")}`;
+}
+
+function buildBackfillRows(): BackfillRow[] {
+  const out: BackfillRow[] = [];
+  const now = Date.now();
+  for (let i = 0; i < BACKFILL_DAYS; i++) {
+    const d = toLocalDay(now - i * 86_400_000);
+    const entries = listEntriesForDay(d);
+    const digest = readDayDigest(d);
+    const status: BackfillRow["status"] = entries.length === 0 ? "empty"
+      : digest && digest.headline ? "generated"
+      : "pending";
+    const label = i === 0 ? "Today"
+      : i === 1 ? "Yesterday"
+      : new Date(`${d}T12:00:00`).toLocaleDateString("en-US", {
+          weekday: "short", month: "short", day: "numeric",
+        });
+    out.push({
+      date: d,
+      day_label: label,
+      entry_count: entries.length,
+      pr_count: entries.reduce((s, e) => s + e.pr_titles.length, 0),
+      status,
+    });
+  }
+  return out;
+}
+
+export default async function DayPage({
+  params,
+}: {
+  params: Promise<{ date: string }>;
+}) {
+  const { date } = await params;
+  if (!isValidDate(date)) return notFound();
+
+  const today = todayLocal();
+  if (date > today) {
+    return (
+      <div style={{ padding: "40px" }}>
+        <h1>Future date</h1>
+        <p>Day views only exist for past and current days.</p>
+        <Link href={`/day/${today}`}>Go to today →</Link>
+      </div>
+    );
+  }
+
+  // ---- Narrative side (digest + entries) ----
+  const settings = readSettings();
+  const aiEnabled = settings.ai_features.enabled;
+  const entries = listEntriesForDay(date);
+  // Today's digest lives only in the 10-min in-memory TTL cache — never on disk.
+  // Falling back to deterministic-only would erase the LLM narrative the user
+  // just generated; the today branch reads the cache instead of disk.
+  let initial: DayDigest | null = date === today
+    ? getTodayDigestFromCache(date, Date.now())
+    : readDayDigest(date);
+  if (!initial && entries.length > 0) initial = buildDeterministicDigest(date, entries);
+
+  // ---- Timeline side (Gantt) ----
+  const [y, m, d] = date.split("-").map(Number) as [number, number, number];
+  const dayStartMs = new Date(y, m - 1, d).getTime();
+  const dayEndMs = new Date(y, m - 1, d + 1).getTime();
+  const filterStartMs = dayStartMs - 24 * 60 * 60 * 1000;
+  const filterEndMs = dayEndMs + 24 * 60 * 60 * 1000;
+  const allSessions = await listSessions();
+  const candidates = allSessions.filter((s) => {
+    if (!s.firstTimestamp) return false;
+    const startMs = Date.parse(s.firstTimestamp);
+    if (Number.isNaN(startMs)) return false;
+    const endMs = s.lastTimestamp ? Date.parse(s.lastTimestamp) : startMs;
+    return endMs >= filterStartMs && startMs <= filterEndMs;
+  });
+  const details = (
+    await Promise.all(candidates.slice(0, 80).map((s) => getSession(s.id)))
+  ).filter((d): d is NonNullable<typeof d> => !!d);
+  const gantt: GanttDay = buildGanttDay(details, date);
+  const bursts: ParallelismBurst[] = computeParallelismBursts(gantt);
+
+  const entriesIndex = await buildEntriesIndex();
+  const sessionEntries: Record<string, SessionEntrySummary> = {};
+  for (const s of gantt.sessions) {
+    const list = entriesIndex.bySession.get(s.id) ?? [];
+    const e = list.find((e) => e.local_day === date);
+    if (!e) continue;
+    sessionEntries[s.id] = {
+      outcome: e.enrichment.outcome ?? null,
+      briefSummary: e.enrichment.brief_summary ?? null,
+      enrichmentStatus: e.enrichment.status,
+      localDay: e.local_day,
+    };
+  }
+
+  const prev = addDays(date, -1);
+  const next = addDays(date, 1);
+  const backfillRows = buildBackfillRows();
+
+  // Calendar popover stats: per-day activity + parallelism stats so the
+  // calendar tints by airtime and dots days with concurrency bursts.
+  const buckets = dailyActivity(allSessions);
+  const allBursts = computeBurstsFromSessions(allSessions);
+  type DayBurstAgg = { totalMs: number; count: number; peak: number };
+  const burstsByDay = new Map<string, DayBurstAgg>();
+  for (const b of allBursts) {
+    const day = toLocalDayParser(b.startMs);
+    const e = burstsByDay.get(day) ?? { totalMs: 0, count: 0, peak: 0 };
+    e.totalMs += b.endMs - b.startMs;
+    e.count += 1;
+    if (b.peak > e.peak) e.peak = b.peak;
+    burstsByDay.set(day, e);
+  }
+  const dayKeys = new Set<string>();
+  for (const b of buckets) if (b.sessions > 0) dayKeys.add(b.date);
+  for (const d of burstsByDay.keys()) dayKeys.add(d);
+  const dayStats: DayInfo[] = Array.from(dayKeys).map((dt) => {
+    const a = buckets.find((b) => b.date === dt);
+    const burst = burstsByDay.get(dt);
+    return {
+      date: dt,
+      sessions: a?.sessions ?? 0,
+      airTimeMs: a?.airTimeMs ?? 0,
+      parallelMs: burst?.totalMs ?? 0,
+      burstCount: burst?.count ?? 0,
+      peakConcurrency: burst?.peak ?? 0,
+    };
+  });
+
+  return (
+    <DayView
+      date={date}
+      today={today}
+      prev={prev}
+      next={next <= today ? next : null}
+      initial={initial}
+      entries={entries}
+      aiEnabled={aiEnabled}
+      gantt={gantt}
+      bursts={bursts}
+      sessionEntries={sessionEntries}
+      backfillRows={backfillRows}
+      dayStats={dayStats}
+    />
+  );
+}

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

@@ -0,0 +1,8 @@
+import { redirect } from "next/navigation";
+import { todayLocal } from "@/lib/entries";
+
+export const dynamic = "force-dynamic";
+
+export default function DayIndexRedirect() {
+  redirect(`/day/${todayLocal()}`);
+}

package/app/apps/web/app/digest/[date]/page.tsx

@@ -0,0 +1,15 @@
+import { redirect } from "next/navigation";
+import { isValidDate } from "@/lib/entries";
+import { notFound } from "next/navigation";
+
+export const dynamic = "force-dynamic";
+
+export default async function LegacyDigestRedirect({
+  params,
+}: {
+  params: Promise<{ date: string }>;
+}) {
+  const { date } = await params;
+  if (!isValidDate(date)) return notFound();
+  redirect(`/day/${date}`);
+}