fleetlens 0.4.0 → 0.6.0

package/app/apps/web/components/yesterday-hero.tsx

@@ -0,0 +1,110 @@
+import Link from "next/link";
+import { readDayDigest, listEntriesForDay } from "@claude-lens/entries/fs";
+import { buildDeterministicDigest, readSettings } from "@claude-lens/entries/node";
+import type { DayDigest } from "@claude-lens/entries";
+import { yesterdayLocal, toLocalDay } from "@/lib/entries";
+import { AutoGenerateYesterday } from "./auto-generate-yesterday";
+
+function fmtDateShort(date: string): string {
+  return new Date(`${date}T12:00:00`).toLocaleDateString("en-US", {
+    weekday: "long", month: "short", day: "numeric",
+  });
+}
+
+function firstSentence(s: string | null): string | null {
+  if (!s) return null;
+  const m = /^[^.!?]+[.!?]/.exec(s);
+  return m ? m[0] : s;
+}
+
+function truncate(s: string, n: number): string {
+  return s.length > n ? s.slice(0, n - 1) + "…" : s;
+}
+
+/** Returns the most recent local day (< today) that has any entries. */
+function mostRecentActiveDay(): string | null {
+  for (let i = 1; i <= 30; i++) {
+    const d = toLocalDay(Date.now() - i * 86_400_000);
+    if (listEntriesForDay(d).length > 0) return d;
+  }
+  return null;
+}
+
+export function YesterdayHero() {
+  const aiEnabled = readSettings().ai_features.enabled;
+  const yesterday = yesterdayLocal();
+  let date = yesterday;
+  let entries = listEntriesForDay(yesterday);
+  let fallback = false;
+
+  if (entries.length === 0) {
+    const recent = mostRecentActiveDay();
+    if (recent) {
+      date = recent;
+      entries = listEntriesForDay(recent);
+      fallback = true;
+    }
+  }
+
+  if (entries.length === 0) {
+    return (
+      <div className="af-panel" style={{ padding: 24, textAlign: "center" }}>
+        <p style={{ color: "var(--af-text-secondary)" }}>
+          No recent activity yet. Once you run some Claude Code sessions, your daily digest will appear here.
+        </p>
+      </div>
+    );
+  }
+
+  const persisted = readDayDigest(date);
+  const digest: DayDigest = persisted ?? buildDeterministicDigest(date, entries);
+  // "Missing" = no persisted digest on disk and the deterministic fallback
+  // has no narrative. The auto-gen trigger looks at this to decide.
+  const narrativeMissing = aiEnabled && !fallback && digest.headline === null;
+
+  const headline = digest.headline
+    ?? `Worked ${Math.round(digest.agent_min)}m across ${digest.projects.length} project${digest.projects.length === 1 ? "" : "s"}${digest.shipped.length > 0 ? `; shipped ${digest.shipped.length} PR${digest.shipped.length === 1 ? "" : "s"}` : ""}.`;
+
+  const wentWell = firstSentence(digest.what_went_well);
+  const friction = firstSentence(digest.what_hit_friction);
+
+  return (
+    <div className="af-panel" style={{ padding: 20, display: "flex", flexDirection: "column", gap: 12 }}>
+      <div>
+        <div style={{
+          display: "flex", alignItems: "center", gap: 10, flexWrap: "wrap",
+          fontSize: 11, color: "var(--af-text-tertiary)",
+          textTransform: "uppercase", letterSpacing: "0.08em", fontWeight: 600,
+        }}>
+          <span>{fallback ? "Last active" : "Yesterday"} · {fmtDateShort(date)}</span>
+          <AutoGenerateYesterday yesterdayDate={date} missing={narrativeMissing} />
+        </div>
+        <h2 style={{ fontSize: 17, fontWeight: 600, margin: "8px 0 0", lineHeight: 1.35 }}>
+          {truncate(headline, 180)}
+        </h2>
+      </div>
+      <div style={{ fontSize: 12, color: "var(--af-text-secondary)", fontFamily: "var(--font-mono)" }}>
+        {Math.round(digest.agent_min)}m agent time · {digest.projects.length} project{digest.projects.length === 1 ? "" : "s"} · {digest.shipped.length} PR{digest.shipped.length === 1 ? "" : "s"} shipped
+      </div>
+      {(wentWell || friction) && (
+        <div style={{ fontSize: 13, display: "flex", flexDirection: "column", gap: 4 }}>
+          {wentWell && <div><span style={{ color: "#48bb78" }}>✓</span> {truncate(wentWell, 160)}</div>}
+          {friction && <div><span style={{ color: "#ed8936" }}>⚠</span> {truncate(friction, 160)}</div>}
+        </div>
+      )}
+      {!aiEnabled && (
+        <div style={{ fontSize: 11, color: "var(--af-text-tertiary)" }}>
+          <Link href="/settings" style={{ color: "var(--af-accent)" }}>Enable AI features</Link> to see daily narratives.
+        </div>
+      )}
+      <div style={{ display: "flex", gap: 12, marginTop: 4 }}>
+        <Link href={`/digest/${date}`} style={{ fontSize: 12, color: "var(--af-accent)" }}>
+          Open full digest →
+        </Link>
+        <Link href="/insights" style={{ fontSize: 12, color: "var(--af-accent)" }}>
+          Weekly insight report →
+        </Link>
+      </div>
+    </div>
+  );
+}

package/app/apps/web/lib/auto-week-fire.ts

@@ -0,0 +1,37 @@
+import "server-only";
+import { existsSync, readFileSync, mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+
+function autoFireFile(): string {
+  return process.env.CCLENS_AUTO_WEEK_FILE
+    ?? join(homedir(), ".cclens", "auto-week-fired-at");
+}
+
+const MONDAY_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+/**
+ * Returns true if this call is the one that should trigger auto-fire for `monday`.
+ * Atomically updates the on-disk record so subsequent calls in the same ISO week
+ * return false. Idempotent across server restarts.
+ *
+ * Corrupt/unreadable file is treated as "absent" — the caller will fire and
+ * the file will be rewritten with a clean Monday line.
+ */
+export function shouldAutoFireWeek(monday: string): boolean {
+  const file = autoFireFile();
+  let prev: string | null = null;
+  if (existsSync(file)) {
+    try {
+      const raw = readFileSync(file, "utf8").trim();
+      if (MONDAY_RE.test(raw)) prev = raw;
+    } catch { /* corrupt — treat as absent */ }
+  }
+  if (prev === monday) return false;
+
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  writeFileSync(tmp, monday + "\n", "utf8");
+  renameSync(tmp, file);
+  return true;
+}

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

@@ -0,0 +1,171 @@
+import "server-only";
+import { cache } from "react";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { loadCalibrationCurve } from "@claude-lens/parser/fs";
+import type { PlanTier, RateSource } from "@claude-lens/parser";
+
+// One point on the calibration overlay — pairs the daemon's measured
+// utilization (when a snapshot landed in the slot) with the JSONL-derived
+// prediction. Used by the /usage burndown overlay and by the Calibration
+// Check chart.
+export type CalibrationPoint = {
+  ts: string;
+  real_5h: number | null;
+  pred_5h: number;
+  real_7d: number | null;
+  pred_7d: number;
+  /** ISO `resets_at` for the cycle this point belongs to. Lets the
+   * summary helper bucket points into cycles without sniffing for
+   * value drops. May be null for cold-start back-fill that lands
+   * before any known reset. */
+  cycle_end_5h?: string | null;
+  cycle_end_7d?: string | null;
+};
+
+export type CalibrationDump = {
+  curve: CalibrationPoint[];
+  // Older Python dumps had per-feature coefficients; the $-rate predictor
+  // doesn't, so these are optional. Kept around so existing chart code
+  // that may inspect them doesn't crash on undefined.
+  coefs_5h?: number[];
+  coefs_7d?: number[];
+  rate_per_pct?: number;
+  rate_per_pct_5h?: number;
+  rate_per_pct_7d?: number;
+  rate_source_5h?: RateSource;
+  rate_source_7d?: RateSource;
+  cycles_used_5h?: number;
+  cycles_used_7d?: number;
+  tier?: string;
+};
+
+export type PredictedSeriesByKey = {
+  five_hour: { capturedAt: number; util: number }[];
+  seven_day: { capturedAt: number; util: number }[];
+  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);
+}
+
+// Converts the calibration dump into the same shape UsageChart expects to
+// overlay on each burndown plot. seven_day_sonnet has no predictor today
+// so it returns empty — the chart will simply not show an estimate line.
+export function predictedSeriesFor(dump: CalibrationDump | null): PredictedSeriesByKey {
+  if (!dump) return { five_hour: [], seven_day: [], seven_day_sonnet: [] };
+  const five_hour = dump.curve
+    .filter((c) => Number.isFinite(c.pred_5h))
+    .map((c) => ({ capturedAt: new Date(c.ts).getTime(), util: Math.max(0, c.pred_5h) }));
+  const seven_day = dump.curve
+    .filter((c) => Number.isFinite(c.pred_7d))
+    .map((c) => ({ capturedAt: new Date(c.ts).getTime(), util: Math.max(0, c.pred_7d) }));
+  return { five_hour, seven_day, seven_day_sonnet: [] };
+}
+
+// Default tier when we can't infer the user's subscription from anywhere.
+// /api/oauth/profile auto-detects this on each daemon push but for cold
+// start we fall back to the heaviest tier so cold-start back-fill predicts
+// the longest possible windows. The profile cache lives next to the JSON
+// dump and is read below if available.
+const PROFILE_CACHE = join(homedir(), ".cclens", "profile.json");
+const DEFAULT_TIER: PlanTier = "pro-max-20x";
+
+function readTier(): PlanTier {
+  if (!existsSync(PROFILE_CACHE)) return DEFAULT_TIER;
+  try {
+    const raw = JSON.parse(readFileSync(PROFILE_CACHE, "utf8"));
+    // Cache shape from writeCachedProfile: { fetchedAtMs, profile: { planTier, ... } }.
+    const t = raw?.profile?.planTier as PlanTier | undefined;
+    if (t === "pro" || t === "pro-max" || t === "pro-max-20x" || t === "custom") return t;
+  } catch {
+    /* ignore — fall back to default */
+  }
+  return DEFAULT_TIER;
+}
+
+// Computed live from JSONL transcripts + ~/.cclens/usage.jsonl, replacing
+// the Python sidecar that previously wrote ~/.cclens/calibration-debug.json.
+// The walk is heavy on first call but cached at multiple levels (parser's
+// mtime cache + React's per-request `cache()`).
+export const readCalibrationDump = cache(
+  async (): Promise<CalibrationDump | null> => {
+    const tier = readTier();
+    const result = await loadCalibrationCurve(tier);
+    if (!result) return null;
+    return {
+      curve: result.curve,
+      rate_per_pct: result.rate_per_pct,
+      rate_per_pct_5h: result.rate_per_pct_5h,
+      rate_per_pct_7d: result.rate_per_pct_7d,
+      rate_source_5h: result.rate_source_5h,
+      rate_source_7d: result.rate_source_7d,
+      cycles_used_5h: result.cycles_used_5h,
+      cycles_used_7d: result.cycles_used_7d,
+      tier: result.tier,
+    };
+  },
+);

package/app/apps/web/lib/entries-index.ts

@@ -0,0 +1,174 @@
+import "server-only";
+import { statSync, existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import {
+  entriesDir,
+  listEntryKeys,
+  readEntry,
+  readDayDigest,
+} from "@claude-lens/entries/fs";
+import type { Entry, DayOutcome, DayHelpfulness, DayDigest } from "@claude-lens/entries";
+import { canonicalProjectName } from "@claude-lens/parser";
+import { outcomePriority } from "@/components/outcome-pill";
+
+export type EntriesIndex = {
+  bySession: Map<string, Entry[]>;
+  byDay: Map<string, Entry[]>;
+  byProject: Map<string, Entry[]>;
+  sessionOutcome: Map<string, DayOutcome | null>;
+  dayOutcome: Map<string, DayOutcome | null>;
+  /** Compact slice for the live-sessions widget — no full entries needed. */
+  enrichmentStatusBySession: Map<string, Entry["enrichment"]["status"]>;
+};
+
+const EMPTY_INDEX: EntriesIndex = {
+  bySession: new Map(),
+  byDay: new Map(),
+  byProject: new Map(),
+  sessionOutcome: new Map(),
+  dayOutcome: new Map(),
+  enrichmentStatusBySession: new Map(),
+};
+
+let cache: { mtimeMs: number; index: EntriesIndex } | null = null;
+
+function dirMtime(): number {
+  const dir = entriesDir();
+  if (!existsSync(dir)) return 0;
+  return statSync(dir).mtimeMs;
+}
+
+export function rollupOutcome(entries: Entry[]): DayOutcome | null {
+  let best: DayOutcome | null = null;
+  let bestPri = 0;
+  for (const e of entries) {
+    const o = e.enrichment.outcome ?? null;
+    if (!o) continue;
+    const pri = outcomePriority(o);
+    if (pri > bestPri) {
+      bestPri = pri;
+      best = o;
+    }
+  }
+  return best;
+}
+
+export async function buildEntriesIndex(): Promise<EntriesIndex> {
+  const mtime = dirMtime();
+  if (mtime === 0) return EMPTY_INDEX;
+  if (cache && cache.mtimeMs === mtime) return cache.index;
+
+  const bySession = new Map<string, Entry[]>();
+  const byDay = new Map<string, Entry[]>();
+  const byProject = new Map<string, Entry[]>();
+  const enrichmentStatusBySession = new Map<string, Entry["enrichment"]["status"]>();
+
+  for (const key of listEntryKeys()) {
+    const sep = key.lastIndexOf("__");
+    if (sep === -1) continue;
+    const sessionId = key.slice(0, sep);
+    const localDay = key.slice(sep + 2);
+    const e = readEntry(sessionId, localDay);
+    if (!e) continue;
+
+    const list = bySession.get(e.session_id);
+    if (list) list.push(e); else bySession.set(e.session_id, [e]);
+
+    const dlist = byDay.get(e.local_day);
+    if (dlist) dlist.push(e); else byDay.set(e.local_day, [e]);
+
+    const canonical = canonicalProjectName(e.project);
+    const plist = byProject.get(canonical);
+    if (plist) plist.push(e); else byProject.set(canonical, [e]);
+
+    // Most recent enrichment status wins for the session-level summary
+    const cur = enrichmentStatusBySession.get(e.session_id);
+    if (!cur || cur === "pending" || cur === "error") {
+      enrichmentStatusBySession.set(e.session_id, e.enrichment.status);
+    }
+  }
+
+  // Sort each session's entries by local_day asc
+  for (const list of bySession.values()) {
+    list.sort((a, b) => a.local_day.localeCompare(b.local_day));
+  }
+
+  const sessionOutcome = new Map<string, DayOutcome | null>();
+  for (const [sid, entries] of bySession) {
+    sessionOutcome.set(sid, rollupOutcome(entries));
+  }
+
+  const dayOutcome = new Map<string, DayOutcome | null>();
+  for (const [day, entries] of byDay) {
+    dayOutcome.set(day, rollupOutcome(entries));
+  }
+
+  const index: EntriesIndex = {
+    bySession,
+    byDay,
+    byProject,
+    sessionOutcome,
+    dayOutcome,
+    enrichmentStatusBySession,
+  };
+  cache = { mtimeMs: mtime, index };
+  return index;
+}
+
+/* ============================================================ */
+/* Day-digest cache lookups (separate, lighter cache)            */
+/* ============================================================ */
+
+export type DayDigestSummary = {
+  date: string;
+  headline: string | null;
+  outcome_day: DayOutcome | null;
+  helpfulness_day: DayHelpfulness;
+  agent_min: number;
+  shipped_count: number;
+};
+
+let digestCache: { mtimeMs: number; map: Map<string, DayDigestSummary> } | null = null;
+
+function digestsDir(): string {
+  return process.env.CCLENS_DIGESTS_DIR ?? join(homedir(), ".cclens", "digests", "day");
+}
+
+function digestsDirMtime(): number {
+  const d = digestsDir();
+  if (!existsSync(d)) return 0;
+  return statSync(d).mtimeMs;
+}
+
+export async function listCachedDayDigests(): Promise<Map<string, DayDigestSummary>> {
+  const mtime = digestsDirMtime();
+  if (mtime === 0) return new Map();
+  if (digestCache && digestCache.mtimeMs === mtime) return digestCache.map;
+
+  const dir = digestsDir();
+  const out = new Map<string, DayDigestSummary>();
+  for (const f of readdirSync(dir)) {
+    if (!f.endsWith(".json")) continue;
+    const date = f.slice(0, -".json".length);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue;
+    const d: DayDigest | null = readDayDigest(date);
+    if (!d) continue;
+    out.set(date, {
+      date,
+      headline: d.headline,
+      outcome_day: d.outcome_day,
+      helpfulness_day: d.helpfulness_day,
+      agent_min: d.agent_min,
+      shipped_count: d.shipped.length,
+    });
+  }
+  digestCache = { mtimeMs: mtime, map: out };
+  return out;
+}
+
+/** Reset both caches — test-only escape hatch. */
+export function __resetEntriesIndexCacheForTest(): void {
+  cache = null;
+  digestCache = null;
+}

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

@@ -0,0 +1,72 @@
+import "server-only";
+
+export { listEntriesForDay, readDayDigest, writeDayDigest } from "@claude-lens/entries/fs";
+
+export function toLocalDay(ms: number): string {
+  const d = new Date(ms);
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+
+export function yesterdayLocal(nowMs: number = Date.now()): string {
+  return toLocalDay(nowMs - 86_400_000);
+}
+
+export function todayLocal(nowMs: number = Date.now()): string {
+  return toLocalDay(nowMs);
+}
+
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+export function isValidDate(s: string): boolean {
+  return DATE_RE.test(s);
+}
+
+const YEAR_MONTH_RE = /^\d{4}-\d{2}$/;
+export function isValidYearMonth(s: string): boolean {
+  return YEAR_MONTH_RE.test(s);
+}
+
+/** Monday of the ISO week containing localDay (Mon-Sun, server local TZ). */
+export function mondayOf(localDay: string): string {
+  const d = new Date(`${localDay}T00:00:00`);
+  const dow = d.getDay();
+  const offset = dow === 0 ? -6 : 1 - dow;
+  d.setDate(d.getDate() + offset);
+  return toLocalDay(d.getTime());
+}
+
+export function currentWeekMonday(nowMs: number = Date.now()): string {
+  return mondayOf(todayLocal(nowMs));
+}
+
+/** Most recent COMPLETED week — last week's Monday. */
+export function lastCompletedWeekMonday(nowMs: number = Date.now()): string {
+  const thisMonday = currentWeekMonday(nowMs);
+  const d = new Date(`${thisMonday}T00:00:00`);
+  d.setDate(d.getDate() - 7);
+  return toLocalDay(d.getTime());
+}
+
+export function currentYearMonth(nowMs: number = Date.now()): string {
+  const today = todayLocal(nowMs);
+  return today.slice(0, 7);
+}
+
+export function lastCompletedMonth(nowMs: number = Date.now()): string {
+  const today = todayLocal(nowMs);
+  const [y, m] = today.split("-");
+  const yi = Number(y);
+  const mi = Number(m);
+  if (mi === 1) return `${yi - 1}-12`;
+  return `${yi}-${String(mi - 1).padStart(2, "0")}`;
+}
+
+/** Validates and returns the Monday for `s` if `s` is itself a Monday in YYYY-MM-DD form. */
+export function asMonday(s: string): string | null {
+  if (!isValidDate(s)) return null;
+  const d = new Date(`${s}T00:00:00`);
+  if (d.getDay() !== 1) return null;
+  return s;
+}

package/app/apps/web/lib/inflight-coalesce.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { InflightCoalescer } from "./inflight-coalesce";
+
+describe("InflightCoalescer", () => {
+  it("second caller with same key awaits the first; worker runs once", async () => {
+    const c = new InflightCoalescer<string, string>();
+    let runs = 0;
+    const worker = async () => { runs++; await new Promise(r => setTimeout(r, 10)); return "ok"; };
+
+    const [a, b] = await Promise.all([
+      c.run("k1", worker),
+      c.run("k1", worker),
+    ]);
+    expect(a).toBe("ok");
+    expect(b).toBe("ok");
+    expect(runs).toBe(1);
+  });
+
+  it("different keys run independently", async () => {
+    const c = new InflightCoalescer<string, string>();
+    let runs = 0;
+    const worker = async () => { runs++; return "ok"; };
+    await Promise.all([c.run("k1", worker), c.run("k2", worker)]);
+    expect(runs).toBe(2);
+  });
+
+  it("drops entry after resolution so subsequent same-key call re-runs", async () => {
+    const c = new InflightCoalescer<string, string>();
+    let runs = 0;
+    const worker = async () => { runs++; return "ok"; };
+    await c.run("k1", worker);
+    await c.run("k1", worker);
+    expect(runs).toBe(2);
+  });
+
+  it("drops entry after rejection and propagates the error", async () => {
+    const c = new InflightCoalescer<string, string>();
+    const failing = async (): Promise<string> => { throw new Error("boom"); };
+    await expect(c.run("k1", failing)).rejects.toThrow("boom");
+    const ok = await c.run("k1", async () => "ok");
+    expect(ok).toBe("ok");
+  });
+});

package/app/apps/web/lib/inflight-coalesce.ts

@@ -0,0 +1,19 @@
+export class InflightCoalescer<K, V> {
+  private readonly map = new Map<K, Promise<V>>();
+
+  async run(key: K, worker: () => Promise<V>): Promise<V> {
+    const existing = this.map.get(key);
+    if (existing) return existing;
+    const p = worker();
+    this.map.set(key, p);
+    try {
+      return await p;
+    } finally {
+      this.map.delete(key);
+    }
+  }
+
+  inflight(key: K): boolean {
+    return this.map.has(key);
+  }
+}