- {overdueLabel ? (
+ {windowStatus?.takenEarlyDaysAgo != null ? (
+ // v1.16.9 — last-dose context outranks the overdue line: a
+ // day-scale dose already taken earlier in its period must never
+ // escalate into a take prompt (double-dose risk).
+
+ ) : overdueLabel ? (
{overdueLabel}
diff --git a/src/components/medications/card-parts/medication-status-pill.tsx b/src/components/medications/card-parts/medication-status-pill.tsx
index db96f15f0..7f9e41be9 100644
--- a/src/components/medications/card-parts/medication-status-pill.tsx
+++ b/src/components/medications/card-parts/medication-status-pill.tsx
@@ -9,6 +9,16 @@ interface MedicationStatusPillProps {
status: Exclude;
windowStart: string;
windowEnd: string;
+ /**
+ * v1.16.9 — day-scale last-dose context. Non-null when a dose was
+ * already taken earlier in the cadence period (a weekly shot days
+ * before its slot day, or the previous slot served late); the pill
+ * then renders a calm factual "last dose {n} days ago" note instead
+ * of the take-now / overdue prompt — prompting a full take on the
+ * slot day would be a double-dose prompt. The value is the whole
+ * local days since that take.
+ */
+ takenEarlyDaysAgo?: number | null;
}
/**
@@ -23,9 +33,27 @@ export function MedicationStatusPill({
status,
windowStart,
windowEnd,
+ takenEarlyDaysAgo = null,
}: MedicationStatusPillProps) {
const { t, locale } = useTranslations();
+ if (takenEarlyDaysAgo != null) {
+ return (
+
+
+
+ {takenEarlyDaysAgo === 1
+ ? t("medications.lastDoseYesterday")
+ : t("medications.lastDoseDaysAgo", { count: takenEarlyDaysAgo })}
+
+
+ {" "}
+ — {formatTimeWindowRange(windowStart, windowEnd, locale)}
+
+
+ );
+ }
+
return (
x + 1, 0);
@@ -288,7 +293,7 @@ export function Glp1MedicationCard({
a.windowStart.localeCompare(b.windowStart) ||
a.windowEnd.localeCompare(b.windowEnd),
);
- const nowBerlin = toBerlinDate(now);
+ const nowBerlin = toZonedDate(now, userTz);
const lateMinutes = thresholds?.lateMinutes ?? 120;
const missedMinutes = thresholds?.missedMinutes ?? 240;
const currentWindowStatus = reduceCurrentWindowStatus({
@@ -299,6 +304,7 @@ export function Glp1MedicationCard({
active: medication.active,
lastTakenAt: medication.lastTakenAt,
todayEventCount: medication.todayEventCount ?? 0,
+ tz: userTz,
// v1.16.6 — gate the pill on the server display-due so a rolling
// cadence whose next injection is days away can never paint an overdue
// pill today. `undefined` (older payloads / fixtures) keeps legacy
@@ -319,6 +325,7 @@ export function Glp1MedicationCard({
currentWindowStatus,
nextDueAt: medication.nextDueAt,
now,
+ timeZone: userTz,
});
// v1.15.9 — the recent-injection list now feeds ONLY the post-dose
@@ -439,6 +446,7 @@ export function Glp1MedicationCard({
// legacy schedule window (which may be stale / degenerate).
windowStart: currentWindowStatus.window!.start,
windowEnd: currentWindowStatus.window!.end,
+ takenEarlyDaysAgo: currentWindowStatus.takenEarlyDaysAgo,
}
: null
}
diff --git a/src/components/medications/medication-card.tsx b/src/components/medications/medication-card.tsx
index af72a7006..30a7a8ec2 100644
--- a/src/components/medications/medication-card.tsx
+++ b/src/components/medications/medication-card.tsx
@@ -13,7 +13,7 @@ import { formatDateTime, formatTime } from "@/lib/format";
import { getMedicationCategoryLabel } from "@/lib/medications/category-label";
import {
reduceCurrentWindowStatus,
- toBerlinDate,
+ toZonedDate,
} from "@/lib/medications/window-status";
import { resolveDisplayedSlotInstant } from "@/components/medications/card-parts/displayed-slot-instant";
import { useTranslations, useFormatters } from "@/lib/i18n/context";
@@ -26,6 +26,7 @@ import { apiGet, apiPost } from "@/lib/api/api-fetch";
import { useMedicationComplianceSummary } from "@/lib/queries/use-medication-compliance-summary";
import { LogInjectionSiteDialog } from "@/components/medications/log-injection-site-dialog";
import { useGlobalExcludedInjectionSites } from "@/lib/medications/use-injection-site-prefs";
+import { useAuth } from "@/hooks/use-auth";
import type { InjectionSiteKey } from "@/lib/medications/injection-sites";
interface Schedule {
@@ -104,6 +105,11 @@ export function MedicationCard({
}: MedicationCardProps) {
const queryClient = useQueryClient();
const { t, locale } = useTranslations();
+ // v1.16.9 — the card reasons in the PROFILE timezone (the snapshot the
+ // session carries); Berlin stays the last-resort fallback so logged-out
+ // mounts and legacy fixtures behave unchanged.
+ const { user } = useAuth();
+ const userTz = user?.timezone || "Europe/Berlin";
const fmt = useFormatters();
const weekdayLabel = useWeekdayLabel();
// v1.8.5 — post-dose injection-site prompt state. Holds the intake
@@ -199,7 +205,7 @@ export function MedicationCard({
a.windowStart.localeCompare(b.windowStart) ||
a.windowEnd.localeCompare(b.windowEnd),
);
- const nowBerlin = toBerlinDate(new Date());
+ const nowBerlin = toZonedDate(new Date(), userTz);
// v1.8.4 — the next-due instant comes from the server (`nextDueAt`,
// computed by the canonical recurrence engine anchored on the last
// intake). The day label below derives from it; the window-range /
@@ -224,6 +230,7 @@ export function MedicationCard({
active: medication.active,
lastTakenAt: medication.lastTakenAt,
todayEventCount: medication.todayEventCount ?? 0,
+ tz: userTz,
// v1.16.6 — gate the pill on the server display-due so a rolling
// cadence whose next dose is tomorrow can never paint an overdue pill
// today. `undefined` (older payloads / fixtures) keeps legacy behaviour.
@@ -231,7 +238,10 @@ export function MedicationCard({
medication.nextDueAt === undefined
? undefined
: nextAt !== undefined
- ? { at: new Date(nextAt), overdue: medication.nextDueOverdue === true }
+ ? {
+ at: new Date(nextAt),
+ overdue: medication.nextDueOverdue === true,
+ }
: null,
});
@@ -244,6 +254,7 @@ export function MedicationCard({
currentWindowStatus,
nextDueAt: medication.nextDueAt,
now: new Date(),
+ timeZone: userTz,
});
function formatLastTakenAt(value: string): string {
@@ -251,7 +262,7 @@ export function MedicationCard({
// string-comparable for the today / yesterday / older bucketing below.
// The actual user-facing display goes through formatTime / formatDateTime.
const dayFormatter = new Intl.DateTimeFormat("en-CA", {
- timeZone: "Europe/Berlin",
+ timeZone: userTz,
year: "numeric",
month: "2-digit",
day: "2-digit",
@@ -314,7 +325,7 @@ export function MedicationCard({
// Format day label relative to today
let dayLabel = "";
if (nextAt) {
- const nextDate = toBerlinDate(new Date(nextAt));
+ const nextDate = toZonedDate(new Date(nextAt), userTz);
const todayStr = `${nowBerlin.getFullYear()}-${nowBerlin.getMonth()}-${nowBerlin.getDate()}`;
const nextStr = `${nextDate.getFullYear()}-${nextDate.getMonth()}-${nextDate.getDate()}`;
const tomorrow = new Date(nowBerlin);
@@ -381,13 +392,16 @@ export function MedicationCard({
// legacy schedule window (which may be stale / degenerate).
windowStart: currentWindowStatus.window!.start,
windowEnd: currentWindowStatus.window!.end,
+ takenEarlyDaysAgo: currentWindowStatus.takenEarlyDaysAgo,
}
: null
}
doseStatus={doseStatus}
nextLine={nextLine}
lastLine={
- medication.lastTakenAt ? formatLastTakenAt(medication.lastTakenAt) : null
+ medication.lastTakenAt
+ ? formatLastTakenAt(medication.lastTakenAt)
+ : null
}
compliance={
compliance ? { rate7, rate30, streak, shortDays, longDays } : null
diff --git a/src/components/settings/__tests__/dashboard-layout-section.test.tsx b/src/components/settings/__tests__/dashboard-layout-section.test.tsx
index d6d740bde..73ab9f58f 100644
--- a/src/components/settings/__tests__/dashboard-layout-section.test.tsx
+++ b/src/components/settings/__tests__/dashboard-layout-section.test.tsx
@@ -1,5 +1,7 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { renderToStaticMarkup } from "react-dom/server";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
import {
DEFAULT_DASHBOARD_LAYOUT,
@@ -269,6 +271,76 @@ describe(" — iOS-only id skip (v1.7.0)", () => {
});
});
+/**
+ * Dashboard hero (Tagesüberblick) visibility switch — one toggle above
+ * the widget list, persisted as `heroVisible` on the layout blob through
+ * the SAME PUT mutation the widget rows use (the Save button flushes the
+ * draft). SSR smoke assertions + source pins, matching the rest of this
+ * suite (no DOM runtime for state mutation).
+ */
+describe(" — hero visibility switch", () => {
+ it("renders one hero switch above the widget list", () => {
+ const html = render();
+ const switches = html.match(/data-slot="hero-visible-switch"/g) ?? [];
+ expect(switches).toHaveLength(1);
+ // Above the list: the hero switch markup precedes the first widget row.
+ expect(html.indexOf('data-slot="hero-visible-switch"')).toBeLessThan(
+ html.indexOf('data-slot="widget-row"'),
+ );
+ });
+
+ it("labels the switch with the localised copy + description", () => {
+ const de = render(, "de");
+ expect(de).toContain("Tagesüberblick");
+ expect(de).toContain(
+ "Zeigt Begrüßung, Score, Tagesfokus und Dosen-Status ganz oben auf dem Dashboard.",
+ );
+ const en = render();
+ expect(en).toContain("Daily overview");
+ });
+
+ it("reflects heroVisible: default layout → checked, false → unchecked", () => {
+ const checkedHtml = render(
+ ,
+ );
+ const checked = checkedHtml.match(
+ /]*data-slot="hero-visible-switch"[^>]*>/,
+ );
+ expect(checked).not.toBeNull();
+ expect(checked![0]).toContain('data-state="checked"');
+
+ queryState.layout = { ...DEFAULT_DASHBOARD_LAYOUT, heroVisible: false };
+ const uncheckedHtml = render(
+ ,
+ );
+ const unchecked = uncheckedHtml.match(
+ /]*data-slot="hero-visible-switch"[^>]*>/,
+ );
+ expect(unchecked).not.toBeNull();
+ expect(unchecked![0]).toContain('data-state="unchecked"');
+ });
+
+ it("persists through the existing PUT draft flow (source pins)", () => {
+ const src = readFileSync(
+ join(
+ process.cwd(),
+ "src/components/settings/dashboard-layout-section.tsx",
+ ),
+ "utf8",
+ );
+ // The toggle writes the flag onto the layout draft…
+ expect(src).toMatch(
+ /setDraft\(\{\s*\.\.\.layout,\s*heroVisible:\s*value\s*\}\)/,
+ );
+ // …which the Save button flushes via the one save mutation
+ // (`apiPut("/api/dashboard/widgets", …)`) every other control uses.
+ expect(src).toMatch(/onCheckedChange=\{\(v\) => setHeroVisible\(v\)\}/);
+ expect(src).toMatch(
+ /apiPut\("\/api\/dashboard\/widgets", next\)/,
+ );
+ });
+});
+
/**
* v1.11.2 HIGH-1 — the 8 B5 ids are WRITABLE (in DASHBOARD_WIDGET_IDS so the
* iOS pin PUT validates them) but have NO web render path, so the web
diff --git a/src/components/settings/dashboard-layout-section.tsx b/src/components/settings/dashboard-layout-section.tsx
index 304cbcfe0..0699eb892 100644
--- a/src/components/settings/dashboard-layout-section.tsx
+++ b/src/components/settings/dashboard-layout-section.tsx
@@ -153,6 +153,8 @@ export function DashboardLayoutSection({ id }: { id: string }) {
// tooltip. One hint paragraph is rendered once at the bottom of the list
// and referenced by every drag handle in this section.
const dragHintId = useId();
+ // Label ↔ switch hookup for the hero (Tagesüberblick) toggle below.
+ const heroToggleId = useId();
// v1.4.47 W4 — sensors: pointer for mouse/touch, keyboard for Tab + Space
// + arrow-key reordering. The KeyboardSensor still works for users who
@@ -243,6 +245,16 @@ export function DashboardLayoutSection({ id }: { id: string }) {
setDraft({ ...layout, comparisonBaseline: value });
}
+ /**
+ * Dashboard hero (daily verdict) visibility. Rides the layout blob
+ * (`heroVisible`, default on) and persists through the same PUT the
+ * widget toggles use — the Save button flushes it.
+ */
+ function setHeroVisible(value: boolean) {
+ if (!layout) return;
+ setDraft({ ...layout, heroVisible: value });
+ }
+
/**
* v1.4.48 M6a — the arrow buttons now delegate to `reorderWidgets()`
* so the swap-and-renumber logic lives in exactly one place. The
@@ -377,6 +389,33 @@ export function DashboardLayoutSection({ id }: { id: string }) {
diff --git a/src/lib/__tests__/dashboard-layout.test.ts b/src/lib/__tests__/dashboard-layout.test.ts
index 0a8fe9a33..964ede10a 100644
--- a/src/lib/__tests__/dashboard-layout.test.ts
+++ b/src/lib/__tests__/dashboard-layout.test.ts
@@ -377,6 +377,65 @@ describe("resolveDashboardLayout() — chartOverlayPrefs (v1.4.18)", () => {
});
});
+/**
+ * Dashboard hero (daily verdict) visibility — `heroVisible` piggy-backs
+ * on the layout blob like the B8 comparison baseline. Resolver contract:
+ * anything that is not the literal `false` clamps back to `true`
+ * (default-on for legacy blobs; a stale client cannot poison the field
+ * with a non-boolean). Serializer persists the resolved boolean
+ * explicitly so a re-read never has to guess the default.
+ */
+describe("resolveDashboardLayout() — heroVisible", () => {
+ it("defaults to true for legacy layouts (no field saved)", () => {
+ const legacy = {
+ version: 1,
+ widgets: [{ id: "weight", visible: true, order: 0 }],
+ };
+ expect(resolveDashboardLayout(legacy).heroVisible).toBe(true);
+ });
+
+ it("respects an explicit heroVisible: false", () => {
+ const saved = {
+ version: 1,
+ widgets: [{ id: "weight", visible: true, order: 0 }],
+ heroVisible: false,
+ };
+ expect(resolveDashboardLayout(saved).heroVisible).toBe(false);
+ });
+
+ it("clamps non-boolean values back to true", () => {
+ for (const poisoned of ["false", 0, null, 1, {}]) {
+ const saved = {
+ version: 1,
+ widgets: [{ id: "weight", visible: true, order: 0 }],
+ heroVisible: poisoned,
+ };
+ expect(resolveDashboardLayout(saved).heroVisible).toBe(true);
+ }
+ });
+
+ it("defaults heroVisible to true in DEFAULT_DASHBOARD_LAYOUT", () => {
+ expect(DEFAULT_DASHBOARD_LAYOUT.heroVisible).toBe(true);
+ });
+
+ it("preserves heroVisible: false through serialize → resolve round-trip", () => {
+ const layout: DashboardLayout = {
+ ...DEFAULT_DASHBOARD_LAYOUT,
+ heroVisible: false,
+ };
+ const resolved = resolveDashboardLayout(serializeDashboardLayout(layout));
+ expect(resolved.heroVisible).toBe(false);
+ });
+
+ it("serializer derives true when the field is missing on input", () => {
+ const layout: DashboardLayout = {
+ version: 1,
+ widgets: [{ id: "weight", visible: true, order: 0 }],
+ };
+ expect(serializeDashboardLayout(layout).heroVisible).toBe(true);
+ });
+});
+
/**
* v1.7.0 — full 27-id widget catalogue for the iOS cold-launch seed.
* The catalogue is a pure superset of the server-known ids; the
diff --git a/src/lib/ai/coach/__tests__/snapshot-budget.test.ts b/src/lib/ai/coach/__tests__/snapshot-budget.test.ts
index 063506be0..97ba155be 100644
--- a/src/lib/ai/coach/__tests__/snapshot-budget.test.ts
+++ b/src/lib/ai/coach/__tests__/snapshot-budget.test.ts
@@ -12,6 +12,7 @@ vi.mock("@/lib/db", () => ({
measurement: { findMany: vi.fn() },
moodEntry: { findMany: vi.fn() },
medicationIntakeEvent: { findMany: vi.fn() },
+ medication: { findMany: vi.fn() },
workout: { findMany: vi.fn() },
user: { findUnique: vi.fn() },
},
@@ -67,6 +68,7 @@ const prismaMock = prisma as unknown as {
measurement: { findMany: ReturnType
};
moodEntry: { findMany: ReturnType };
medicationIntakeEvent: { findMany: ReturnType };
+ medication: { findMany: ReturnType };
workout: { findMany: ReturnType };
user: { findUnique: ReturnType };
};
@@ -170,12 +172,51 @@ describe("buildCoachSnapshot — budgeting + progressive degradation", () => {
score: 3 + (i % 3),
})),
);
- prismaMock.medicationIntakeEvent.findMany.mockResolvedValue(
- Array.from({ length: 360 }, (_, i) => ({
- scheduledFor: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
- takenAt: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
- skipped: false,
- })),
+ prismaMock.medicationIntakeEvent.findMany.mockResolvedValue([]);
+ // v1.16.9 — the compliance timeline derives from the band-engine
+ // ledger now; the snapshot loads medications (schedules + window
+ // events) instead of raw intake rows.
+ // Branch on the caller: the GLP-1 block filters on
+ // `treatmentClass: "GLP1"` (no GLP-1 therapy in this fixture); the
+ // compliance loader reads every medication.
+ const complianceMedRows = [
+ {
+ id: "med-1",
+ startsOn: null,
+ endsOn: null,
+ oneShot: false,
+ createdAt: new Date(Date.now() - 400 * 24 * 60 * 60 * 1000),
+ schedules: [
+ {
+ id: "sched-1",
+ windowStart: "09:00",
+ windowEnd: "09:00",
+ daysOfWeek: null,
+ timesOfDay: ["09:00"],
+ reminderGraceMinutes: null,
+ rrule: "FREQ=DAILY",
+ rollingIntervalDays: null,
+ scheduleType: "SCHEDULED",
+ cyclicOnWeeks: null,
+ cyclicOffWeeks: null,
+ doseWindows: null,
+ },
+ ],
+ scheduleRevisions: [],
+ intakeEvents: Array.from({ length: 360 }, (_, i) => ({
+ scheduledFor: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
+ takenAt: new Date(Date.now() - i * 24 * 60 * 60 * 1000),
+ skipped: false,
+ autoMissed: false,
+ attributionSource: "AUTO",
+ })),
+ },
+ ];
+ prismaMock.medication.findMany.mockImplementation(
+ (args: { where?: { treatmentClass?: string } }) =>
+ Promise.resolve(
+ args?.where?.treatmentClass === "GLP1" ? [] : complianceMedRows,
+ ),
);
prismaMock.workout.findMany.mockResolvedValue(
Array.from({ length: 80 }, (_, i) => ({
@@ -295,6 +336,7 @@ describe("buildCoachSnapshot — budgeting + progressive degradation", () => {
prismaMock.measurement.findMany.mockResolvedValue([]);
prismaMock.moodEntry.findMany.mockResolvedValue([]);
prismaMock.medicationIntakeEvent.findMany.mockResolvedValue([]);
+ prismaMock.medication.findMany.mockResolvedValue([]);
prismaMock.workout.findMany.mockResolvedValue([]);
prismaMock.user.findUnique.mockResolvedValue({
coachPrefsJson: null,
diff --git a/src/lib/ai/coach/__tests__/snapshot-new-metrics.test.ts b/src/lib/ai/coach/__tests__/snapshot-new-metrics.test.ts
index f3d565677..df2c12a89 100644
--- a/src/lib/ai/coach/__tests__/snapshot-new-metrics.test.ts
+++ b/src/lib/ai/coach/__tests__/snapshot-new-metrics.test.ts
@@ -10,6 +10,7 @@ vi.mock("@/lib/db", () => ({
measurement: { findMany: vi.fn() },
moodEntry: { findMany: vi.fn() },
medicationIntakeEvent: { findMany: vi.fn() },
+ medication: { findMany: vi.fn() },
workout: { findMany: vi.fn() },
user: { findUnique: vi.fn() },
},
@@ -26,6 +27,7 @@ const prismaMock = prisma as unknown as {
measurement: { findMany: ReturnType };
moodEntry: { findMany: ReturnType };
medicationIntakeEvent: { findMany: ReturnType };
+ medication: { findMany: ReturnType };
workout: { findMany: ReturnType };
user: { findUnique: ReturnType };
};
@@ -60,6 +62,7 @@ describe("buildCoachSnapshot — Apple Health additive metrics (v1.4.23)", () =>
__resetCoachSnapshotCacheForTests();
prismaMock.moodEntry.findMany.mockResolvedValue([]);
prismaMock.medicationIntakeEvent.findMany.mockResolvedValue([]);
+ prismaMock.medication.findMany.mockResolvedValue([]);
prismaMock.workout.findMany.mockResolvedValue([]);
// v1.4.23 H4 — snapshot now reads `User.coachPrefsJson`. Default
// null = legacy defaults so the existing test fixtures stay
diff --git a/src/lib/ai/coach/__tests__/snapshot.test.ts b/src/lib/ai/coach/__tests__/snapshot.test.ts
index a8bfa305a..f7725f414 100644
--- a/src/lib/ai/coach/__tests__/snapshot.test.ts
+++ b/src/lib/ai/coach/__tests__/snapshot.test.ts
@@ -13,6 +13,7 @@ vi.mock("@/lib/db", () => ({
measurement: { findMany: vi.fn() },
moodEntry: { findMany: vi.fn() },
medicationIntakeEvent: { findMany: vi.fn() },
+ medication: { findMany: vi.fn() },
user: { findUnique: vi.fn() },
},
}));
@@ -36,6 +37,7 @@ const prismaMock = prisma as unknown as {
measurement: { findMany: ReturnType };
moodEntry: { findMany: ReturnType };
medicationIntakeEvent: { findMany: ReturnType };
+ medication: { findMany: ReturnType };
user: { findUnique: ReturnType };
};
const featuresMock = extractFeatures as unknown as ReturnType;
@@ -68,6 +70,7 @@ describe("buildCoachSnapshot", () => {
prismaMock.measurement.findMany.mockResolvedValue([]);
prismaMock.moodEntry.findMany.mockResolvedValue([]);
prismaMock.medicationIntakeEvent.findMany.mockResolvedValue([]);
+ prismaMock.medication.findMany.mockResolvedValue([]);
// v1.4.23 H4 — snapshot now reads `User.coachPrefsJson` to apply
// per-user excludeMetrics. Default null = use legacy defaults.
prismaMock.user.findUnique.mockResolvedValue({ coachPrefsJson: null });
diff --git a/src/lib/ai/coach/snapshot.ts b/src/lib/ai/coach/snapshot.ts
index a144309cc..651488c0f 100644
--- a/src/lib/ai/coach/snapshot.ts
+++ b/src/lib/ai/coach/snapshot.ts
@@ -35,6 +35,13 @@ import { buildCoachMemoryBlock } from "./memory-snapshot";
import { buildTrajectorySnapshotBlock } from "./trajectory-snapshot";
import { buildCycleSnapshotBlock } from "./cycle-snapshot";
import { isCycleEnabled } from "@/lib/cycle/gate";
+import {
+ buildComplianceLedgerRows,
+ buildComplianceMedicationContext,
+ lastNonSkippedTakenAt,
+ SCHEDULE_COMPLIANCE_SELECT,
+} from "@/lib/analytics/compliance";
+import type { DoseHistoryRow } from "@/lib/medications/scheduling/dose-history";
import type { BaselineProfile } from "@/lib/insights/derived";
import {
CLUSTER_PRIORITY,
@@ -753,12 +760,46 @@ async function buildCoachSnapshotImpl(
select: { moodLoggedAt: true, score: true },
})
: null;
- const intakeRowsPromise = wantsCompliance
- ? prisma.medicationIntakeEvent.findMany({
- // Tombstoned intake rows must never reach the Coach snapshot.
- where: { userId, deletedAt: null, scheduledFor: { gte: cutoff } },
- orderBy: { scheduledFor: "asc" },
- select: { scheduledFor: true, takenAt: true, skipped: true },
+ // v1.16.9 — the adherence timeline derives from the LEDGER tally (the
+ // same band engine the compliance % + dose history consume), not from a
+ // raw intake-row count. The raw count read a worker-minted pending row
+ // as "not taken" (today's later doses dragged the day's rate down all
+ // morning) and double-counted cross-source duplicate rows on one slot.
+ // Load each medication's schedules + eras + window events so the ledger
+ // can be reconstructed per medication.
+ const complianceMedsPromise = wantsCompliance
+ ? prisma.medication.findMany({
+ where: { userId },
+ select: {
+ id: true,
+ startsOn: true,
+ endsOn: true,
+ oneShot: true,
+ createdAt: true,
+ schedules: { select: SCHEDULE_COMPLIANCE_SELECT },
+ scheduleRevisions: {
+ orderBy: { validFrom: "asc" },
+ select: {
+ id: true,
+ validFrom: true,
+ validUntil: true,
+ payload: true,
+ supersededByRevisionId: true,
+ },
+ },
+ intakeEvents: {
+ // Tombstoned intake rows must never reach the Coach snapshot.
+ where: { deletedAt: null, scheduledFor: { gte: cutoff } },
+ orderBy: { scheduledFor: "asc" },
+ select: {
+ scheduledFor: true,
+ takenAt: true,
+ skipped: true,
+ autoMissed: true,
+ attributionSource: true,
+ },
+ },
+ },
})
: null;
const sleepRowsPromise = sources.has("sleep")
@@ -826,7 +867,7 @@ async function buildCoachSnapshotImpl(
const [
moodRows,
- intakeRows,
+ complianceMeds,
sleepRows,
workoutRows,
glp1Block,
@@ -836,7 +877,7 @@ async function buildCoachSnapshotImpl(
cycleBlock,
] = await Promise.all([
moodRowsPromise,
- intakeRowsPromise,
+ complianceMedsPromise,
sleepRowsPromise,
workoutRowsPromise,
glp1BlockPromise,
@@ -939,31 +980,60 @@ async function buildCoachSnapshotImpl(
registerBlock("mood", "mood");
}
- if (wantsCompliance && intakeRows) {
- // Medication compliance lives outside the structured features
- // today — the legacy Coach surface labelled it as "general"
- // provenance only. v1.4.20.1 ships a per-day adherence row built
- // from the intake-event log so the Coach can answer "did I miss
- // my dose on Tuesday?" without inventing the schedule. The read is
- // issued in parallel above.
- if (intakeRows.length > 0) {
- // Per-day adherence rate within the recent window. Older days
- // collapse into a single weekly bucket.
- const recent = intakeRows.filter((r) => r.scheduledFor >= recentCutoff);
- const olderRows = intakeRows.filter((r) => r.scheduledFor < recentCutoff);
+ if (wantsCompliance && complianceMeds) {
+ // Medication compliance lives outside the structured features today —
+ // the legacy Coach surface labelled it as "general" provenance only.
+ // v1.4.20.1 shipped a per-day adherence row; v1.16.9 derives it from
+ // the band-engine LEDGER (the same expansion the compliance % and the
+ // dose-history view consume): a slot counts against the rate only once
+ // it is genuinely missed, a pending/upcoming slot never reads as "not
+ // taken", deliberate skips and ad-hoc takes stay out of the
+ // denominator, and cross-source duplicate rows collapse onto one slot.
+ const ledgerRows: DoseHistoryRow[] = [];
+ for (const med of complianceMeds) {
+ if (med.schedules.length === 0) continue;
+ const ctx = buildComplianceMedicationContext(
+ med,
+ lastNonSkippedTakenAt(med.intakeEvents),
+ userTz,
+ );
+ ledgerRows.push(
+ ...buildComplianceLedgerRows(
+ med.intakeEvents,
+ med.schedules,
+ ctx,
+ cutoff,
+ now,
+ now,
+ ),
+ );
+ }
+ // Countable rows: taken (on-time or late) or genuinely missed. The
+ // pending / upcoming / skipped / ad-hoc rows carry no adherence signal.
+ const countable = ledgerRows.filter(
+ (r) =>
+ r.status === "taken_on_time" ||
+ r.status === "taken_late" ||
+ r.status === "missed",
+ );
+ if (countable.length > 0) {
+ const recent = countable.filter((r) => r.at >= recentCutoff);
+ const olderRows = countable.filter((r) => r.at < recentCutoff);
+ const isTaken = (r: DoseHistoryRow) =>
+ r.status === "taken_on_time" || r.status === "taken_late";
const recentByDay = new Map<
string,
{ date: Date; total: number; taken: number }
>();
for (const r of recent) {
- const key = tzDayKey(r.scheduledFor, userTz);
+ const key = tzDayKey(r.at, userTz);
const e = recentByDay.get(key) ?? {
- date: r.scheduledFor,
+ date: r.at,
total: 0,
taken: 0,
};
e.total += 1;
- if (r.takenAt && !r.skipped) e.taken += 1;
+ if (isTaken(r)) e.taken += 1;
recentByDay.set(key, e);
}
const recentRows = Array.from(recentByDay.entries())
@@ -977,10 +1047,10 @@ async function buildCoachSnapshotImpl(
.sort((a, b) => a.date.localeCompare(b.date));
const olderByWeek = new Map();
for (const r of olderRows) {
- const key = isoWeekKey(r.scheduledFor, userTz);
+ const key = isoWeekKey(r.at, userTz);
const e = olderByWeek.get(key) ?? { taken: 0, total: 0 };
e.total += 1;
- if (r.takenAt && !r.skipped) e.taken += 1;
+ if (isTaken(r)) e.taken += 1;
olderByWeek.set(key, e);
}
const weeklyRows = Array.from(olderByWeek.entries())
@@ -995,7 +1065,7 @@ async function buildCoachSnapshotImpl(
timeline: { recent: recentRows, weekly: weeklyRows },
};
metrics.add("compliance");
- counts.compliance = intakeRows.length;
+ counts.compliance = countable.length;
registerBlock("compliance", "compliance");
} else {
// v1.7.0 — toggled-on cluster with no rows. Annotate so the
diff --git a/src/lib/auth/profile-update.ts b/src/lib/auth/profile-update.ts
index 7b531e2ce..e38410022 100644
--- a/src/lib/auth/profile-update.ts
+++ b/src/lib/auth/profile-update.ts
@@ -8,7 +8,10 @@ import { auditLog } from "@/lib/auth/audit";
import { profileSchema } from "@/lib/validations/auth";
import { isValidTimezone } from "@/lib/tz/format";
import { encrypt } from "@/lib/crypto";
-import { invalidateUserProfile } from "@/lib/cache/invalidate";
+import {
+ invalidateUserMedications,
+ invalidateUserProfile,
+} from "@/lib/cache/invalidate";
import { z } from "zod/v4";
const extendedProfileSchema = profileSchema.extend({
@@ -168,6 +171,14 @@ export async function applyProfileUpdate(
invalidateUserProfile(userId);
}
+ // v1.16.9 — the medication payloads (list next-due, today counts, the
+ // compliance day buckets) are computed in the user's timezone, but the
+ // list cache key carries only the userId. A timezone change must evict
+ // the bucket or the next read serves the previous zone's day grid.
+ if (data.timezone !== undefined) {
+ invalidateUserMedications(userId, { evict: true });
+ }
+
await auditLog("profile.update", {
userId: updatedUser.id,
ipAddress: ipAddress ?? null,
diff --git a/src/lib/cache/__tests__/server-cache.test.ts b/src/lib/cache/__tests__/server-cache.test.ts
index 12664fbb2..6a0ea86b6 100644
--- a/src/lib/cache/__tests__/server-cache.test.ts
+++ b/src/lib/cache/__tests__/server-cache.test.ts
@@ -451,6 +451,165 @@ describe("ServerCache stale-while-revalidate (wrapSwr / cachedSwr)", () => {
});
});
+describe("ServerCache invalidation vs in-flight builders", () => {
+ it("a read right after an evict does NOT join the pre-write builder", async () => {
+ const cache = new ServerCache({ maxEntries: 4, ttlMs: 60_000 });
+ let releaseFirst: ((v: string) => void) | null = null;
+ let calls = 0;
+ const builder = vi.fn(() => {
+ calls += 1;
+ if (calls === 1) {
+ return new Promise((r) => {
+ releaseFirst = r;
+ });
+ }
+ return Promise.resolve("post-write");
+ });
+
+ // Builder 1 starts (reads pre-write state) and is still in flight…
+ const first = cache.wrap("u1|list", builder);
+ // …when a write evicts the key.
+ cache.delete("u1|list");
+
+ // The next read must start a FRESH build, not join the stale one.
+ const second = await cache.wrap("u1|list", builder);
+ expect(second.outcome).toBe("miss");
+ expect(second.value).toBe("post-write");
+ expect(builder).toHaveBeenCalledTimes(2);
+
+ // The detached pre-write builder resolves AFTER the fresh one — its
+ // commit must be discarded, never overwriting the post-write entry.
+ releaseFirst!("pre-write");
+ const firstResult = await first;
+ expect(firstResult.value).toBe("pre-write");
+ expect(cache.get("u1|list")).toBe("post-write");
+ });
+
+ it("deleteByPrefix fences an in-flight builder the same way", async () => {
+ const cache = new ServerCache({ maxEntries: 4, ttlMs: 60_000 });
+ let release: ((v: string) => void) | null = null;
+ const builder = vi.fn(
+ () =>
+ new Promise((r) => {
+ release = r;
+ }),
+ );
+ const inFlight = cache.wrap("u1|compliance", builder);
+ cache.deleteByPrefix("u1|");
+ release!("pre-write");
+ await inFlight;
+ // The pre-write result never entered the cache.
+ expect(cache.get("u1|compliance")).toBeNull();
+ });
+
+ it("an SWR refresh that completes after an evict does not re-cache the pre-write body", async () => {
+ vi.useFakeTimers();
+ const cache = new ServerCache({
+ maxEntries: 4,
+ ttlMs: 1000,
+ staleTtlMs: 600_000,
+ });
+ let releaseRefresh: ((v: string) => void) | null = null;
+ let calls = 0;
+ const builder = vi.fn(() => {
+ calls += 1;
+ if (calls === 1) return Promise.resolve("v1");
+ if (calls === 2) {
+ return new Promise((r) => {
+ releaseRefresh = r;
+ });
+ }
+ return Promise.resolve("post-write");
+ });
+
+ await cache.wrapSwr("u1|list", builder);
+ vi.advanceTimersByTime(1500);
+
+ // Stale read kicks off the detached background refresh (pre-write).
+ const stale = await cache.wrapSwr("u1|list", builder);
+ expect(stale.outcome).toBe("stale");
+
+ // A write evicts the bucket while the refresh is still in flight…
+ cache.deleteByPrefix("u1|");
+ // …then the pre-write refresh completes. Without the fence it would
+ // re-insert the pre-write body as FRESH for the full TTL.
+ releaseRefresh!("pre-write");
+ await vi.runAllTimersAsync();
+
+ expect(cache.get("u1|list")).toBeNull();
+ const next = await cache.wrapSwr("u1|list", builder);
+ expect(next.outcome).toBe("miss");
+ expect(next.value).toBe("post-write");
+ });
+
+ it("markStaleByPrefix discards an in-flight refresh and keeps SWR semantics", async () => {
+ vi.useFakeTimers();
+ const cache = new ServerCache({
+ maxEntries: 4,
+ ttlMs: 1000,
+ staleTtlMs: 600_000,
+ });
+ let releaseRefresh: ((v: string) => void) | null = null;
+ let calls = 0;
+ const builder = vi.fn(() => {
+ calls += 1;
+ if (calls === 1) return Promise.resolve("v1");
+ if (calls === 2) {
+ return new Promise((r) => {
+ releaseRefresh = r;
+ });
+ }
+ return Promise.resolve("post-write");
+ });
+
+ await cache.wrapSwr("u1|k", builder);
+ vi.advanceTimersByTime(1500);
+ const stale = await cache.wrapSwr("u1|k", builder);
+ expect(stale.outcome).toBe("stale");
+
+ // Background write marks the bucket stale mid-refresh; the pre-write
+ // refresh result must not land as a fresh entry.
+ cache.markStaleByPrefix("u1|");
+ releaseRefresh!("pre-write");
+ await vi.runAllTimersAsync();
+
+ // SWR semantics hold: the prior value still serves stale and a NEW
+ // (post-write) recompute is kicked off.
+ const next = await cache.wrapSwr("u1|k", builder);
+ expect(next.outcome).toBe("stale");
+ expect(next.value).toBe("v1");
+ await vi.runAllTimersAsync();
+ expect(builder).toHaveBeenCalledTimes(3);
+ const warm = await cache.wrapSwr("u1|k", builder);
+ expect(warm.outcome).toBe("hit");
+ expect(warm.value).toBe("post-write");
+ });
+
+ it("invalidation between two stampeding readers gives the later reader fresh data", async () => {
+ const cache = new ServerCache({ maxEntries: 4, ttlMs: 60_000 });
+ let release: ((v: string) => void) | null = null;
+ let calls = 0;
+ const builder = vi.fn(() => {
+ calls += 1;
+ if (calls === 1) {
+ return new Promise((r) => {
+ release = r;
+ });
+ }
+ return Promise.resolve("fresh");
+ });
+
+ const a = cache.wrap("k", builder); // pre-write build in flight
+ cache.delete("k"); // write
+ const b = cache.wrap("k", builder); // post-write read → fresh build
+ release!("stale");
+ const [ra, rb] = await Promise.all([a, b]);
+ expect(ra.value).toBe("stale"); // joined its own (pre-write) build
+ expect(rb.value).toBe("fresh");
+ expect(cache.get("k")).toBe("fresh");
+ });
+});
+
describe("global cache registry", () => {
it("exposes the eight blueprint caches as module-scope singletons", () => {
expect(caches.analytics).toBeDefined();
diff --git a/src/lib/cache/invalidate.ts b/src/lib/cache/invalidate.ts
index c099b2e09..140769403 100644
--- a/src/lib/cache/invalidate.ts
+++ b/src/lib/cache/invalidate.ts
@@ -246,6 +246,38 @@ export function invalidateUserInsightsLayout(userId: string): void {
caches.insightsLayout.deleteByPrefix(userId);
}
+/**
+ * v1.16.9 — full per-user cache eviction for the wipe / restore paths.
+ * A data wipe or a backup restore replaces (or removes) every row the
+ * cached payloads were built on, so every per-user bucket hard-evicts —
+ * a marked-stale SWR cell would keep serving the pre-wipe body.
+ */
+export function invalidateUserData(userId: string): void {
+ caches.analytics.deleteByPrefix(`${userId}|`);
+ caches.medications.deleteByPrefix(userId);
+ caches.medicationCompliance.deleteByPrefix(`${userId}|`);
+ caches.medicationsIntake.deleteByPrefix(`${userId}|`);
+ caches.achievements.deleteByPrefix(userId);
+ caches.insightsTargets.deleteByPrefix(userId);
+ caches.insightsDerived.deleteByPrefix(`${userId}|`);
+ caches.moodAnalytics.deleteByPrefix(userId);
+ caches.moodInsights.deleteByPrefix(userId);
+ caches.workouts.deleteByPrefix(`${userId}|`);
+ caches.dashboardWidgets.deleteByPrefix(userId);
+ caches.insightsLayout.deleteByPrefix(userId);
+}
+
+/**
+ * v1.16.9 — bucket-wide clear for the admin all-user wipe. Every cache
+ * empties; the next read per user is a cold build over the (now empty /
+ * restored) tables. Acceptable for an operation this rare.
+ */
+export function invalidateAllCaches(): void {
+ for (const cache of Object.values(caches)) {
+ cache.deleteByPrefix("");
+ }
+}
+
/**
* Global eviction of the bug-report-status cache.
*
diff --git a/src/lib/cache/server-cache.ts b/src/lib/cache/server-cache.ts
index 3afdd06fa..c19601b2a 100644
--- a/src/lib/cache/server-cache.ts
+++ b/src/lib/cache/server-cache.ts
@@ -67,12 +67,30 @@ export interface ServerCacheStats {
readonly stampedes: number;
}
+/**
+ * v1.16.9 — single-flight slot with invalidation fencing. A builder that
+ * was in flight when an invalidation (`delete` / `deleteByPrefix` /
+ * `markStaleByPrefix`) hit its key must NOT commit its result: the build
+ * read pre-write data, and committing it after the eviction would
+ * re-cache the pre-write body as fresh for the full TTL. The slot is the
+ * fence — invalidation flips `invalidated` and detaches the slot from
+ * `pending`, so (a) the builder's `.then` skips the `set()` and (b) the
+ * next read starts a fresh build instead of joining the stale one.
+ * Callers already awaiting the detached promise still receive its value
+ * (equivalent to having read a moment before the write); it just never
+ * enters the cache.
+ */
+interface PendingBuild {
+ promise: Promise;
+ invalidated: boolean;
+}
+
export class ServerCache {
private readonly map = new Map<
string,
{ expiresAt: number; staleUntil: number; value: T }
>();
- private readonly pending = new Map>();
+ private readonly pending = new Map>();
private hits = 0;
private misses = 0;
private evictions = 0;
@@ -80,6 +98,59 @@ export class ServerCache {
constructor(private readonly opts: ServerCacheOptions) {}
+ /**
+ * Fence + detach the in-flight builder for one key (no-op when none).
+ * Part of every invalidation op — see `PendingBuild`.
+ */
+ private detachPending(key: string): void {
+ const slot = this.pending.get(key);
+ if (slot) {
+ slot.invalidated = true;
+ this.pending.delete(key);
+ }
+ }
+
+ /** Fence + detach every in-flight builder under `prefix`. */
+ private detachPendingByPrefix(prefix: string): void {
+ for (const [key, slot] of this.pending) {
+ if (key.startsWith(prefix)) {
+ slot.invalidated = true;
+ this.pending.delete(key);
+ }
+ }
+ }
+
+ /**
+ * Register a fenced single-flight build for `key`. The commit only
+ * lands when no invalidation hit the key while the builder ran; the
+ * `finally` only clears the slot it owns (an invalidation may already
+ * have detached it and a newer build may occupy the key).
+ */
+ private startBuild(
+ key: string,
+ builder: () => Promise,
+ ttlMsOverride?: number,
+ ): PendingBuild {
+ const slot: PendingBuild = {
+ promise: undefined as unknown as Promise,
+ invalidated: false,
+ };
+ slot.promise = builder()
+ .then((value) => {
+ if (!slot.invalidated) {
+ this.set(key, value, ttlMsOverride);
+ }
+ return value;
+ })
+ .finally(() => {
+ if (this.pending.get(key) === slot) {
+ this.pending.delete(key);
+ }
+ });
+ this.pending.set(key, slot);
+ return slot;
+ }
+
/**
* Read a key. Returns null on miss, expired entry, or absent entry.
* Side effect: an expired entry is removed; a live entry is
@@ -178,6 +249,12 @@ export class ServerCache {
* behaviour).
*/
markStaleByPrefix(prefix: string): number {
+ // v1.16.9 — fence in-flight builders too: a refresh that started
+ // before the write would otherwise complete after this mark and
+ // re-cache the pre-write body as FRESH for the full TTL. Detaching
+ // keeps the SWR contract — the marked entry still serves stale, and
+ // the next read kicks off a fresh (post-write) recompute.
+ this.detachPendingByPrefix(prefix);
let marked = 0;
const now = Date.now();
for (const [key, entry] of this.map) {
@@ -191,6 +268,9 @@ export class ServerCache {
/** Single-key eviction. Returns true when the key was present. */
delete(key: string): boolean {
+ // v1.16.9 — fence the in-flight builder so a pre-write build can
+ // neither be joined by post-evict reads nor commit its result.
+ this.detachPending(key);
return this.map.delete(key);
}
@@ -203,6 +283,8 @@ export class ServerCache {
* possible cache-key variant the user might have warmed.
*/
deleteByPrefix(prefix: string): number {
+ // v1.16.9 — fence in-flight builders under the prefix (see `delete`).
+ this.detachPendingByPrefix(prefix);
let removed = 0;
for (const key of this.map.keys()) {
if (key.startsWith(prefix)) {
@@ -238,21 +320,13 @@ export class ServerCache {
const inFlight = this.pending.get(key);
if (inFlight) {
this.stampedes += 1;
- const value = await inFlight;
+ const value = await inFlight.promise;
return { value, outcome: "stampede" };
}
this.misses += 1;
- const promise = builder()
- .then((value) => {
- this.set(key, value, ttlMsOverride);
- return value;
- })
- .finally(() => {
- this.pending.delete(key);
- });
- this.pending.set(key, promise);
- const value = await promise;
+ const slot = this.startBuild(key, builder, ttlMsOverride);
+ const value = await slot.promise;
return { value, outcome: "miss" };
}
@@ -288,20 +362,11 @@ export class ServerCache {
// single-flight slot so concurrent stale reads share one rebuild.
this.hits += 1;
if (!this.pending.has(key)) {
- const refresh = builder()
- .then((value) => {
- this.set(key, value, ttlMsOverride);
- return value;
- })
- .catch((err) => {
- // The stale value already went out; don't crash the worker.
- // Re-throw so the join path of any awaiting caller sees it.
- throw err;
- })
- .finally(() => {
- this.pending.delete(key);
- });
- this.pending.set(key, refresh);
+ // v1.16.9 — the background refresh runs through the same fenced
+ // single-flight slot as `wrap`, so an invalidation that lands
+ // while it is in flight discards its (pre-write) result instead
+ // of re-caching it as fresh.
+ const refresh = this.startBuild(key, builder, ttlMsOverride).promise;
// Detach: the foreground caller does not await the rebuild.
// Handle the rejection on the detached handle so an
// unhandled-rejection warning never fires — but never silently:
@@ -344,6 +409,11 @@ export class ServerCache {
/** Reset every counter + entry. Test-only escape hatch. */
__resetForTests(): void {
this.map.clear();
+ // Fence any in-flight builder so a build crossing a test boundary
+ // cannot commit into the next test's clean cache.
+ for (const slot of this.pending.values()) {
+ slot.invalidated = true;
+ }
this.pending.clear();
this.hits = 0;
this.misses = 0;
diff --git a/src/lib/dashboard-layout.ts b/src/lib/dashboard-layout.ts
index 50bcc52cd..06c7f3317 100644
--- a/src/lib/dashboard-layout.ts
+++ b/src/lib/dashboard-layout.ts
@@ -321,6 +321,16 @@ export interface DashboardLayout {
comparisonBaseline?: ComparisonBaseline;
/** v1.4.18 — per-chart overlay-prefs (3 toggles per chart card). */
chartOverlayPrefs?: ChartOverlayPrefsMap;
+ /**
+ * Dashboard hero (daily verdict) visibility. Piggy-backs on the
+ * layout blob like the B8 comparison baseline — a UI affordance, not
+ * an analytical attribute, so no Prisma migration. The resolver
+ * clamps anything that is not the literal `false` back to `true`
+ * (legacy blobs without the field render the hero by default; a
+ * stale client cannot poison it with a non-boolean), and the
+ * serializer persists the resolved boolean explicitly.
+ */
+ heroVisible?: boolean;
}
const DASHBOARD_LAYOUT_VERSION = 1;
@@ -332,6 +342,9 @@ const DASHBOARD_LAYOUT_VERSION = 1;
*/
export const DEFAULT_DASHBOARD_LAYOUT: DashboardLayout = {
version: DASHBOARD_LAYOUT_VERSION,
+ // Hero (daily verdict) is on by default; users opt out via
+ // Settings → Dashboard.
+ heroVisible: true,
widgets: [
{ id: "weight", visible: true, tileVisible: true, order: 0 },
{ id: "bp", visible: true, tileVisible: true, order: 1 },
@@ -449,6 +462,10 @@ export function resolveDashboardLayout(raw: unknown): DashboardLayout {
// client cannot poison the dashboard with values the renderer
// doesn't know how to draw.
chartOverlayPrefs: coerceChartOverlayPrefsMap(candidate.chartOverlayPrefs),
+ // Hero visibility — anything that is not the literal `false`
+ // clamps to `true` (default-on for legacy blobs and malformed
+ // values alike).
+ heroVisible: candidate.heroVisible !== false,
};
}
@@ -476,5 +493,8 @@ export function serializeDashboardLayout(
// v1.4.18 — persist per-chart overlay prefs verbatim through the
// same coercion the resolver runs so the wire shape is stable.
chartOverlayPrefs: coerceChartOverlayPrefsMap(layout.chartOverlayPrefs),
+ // Persist hero visibility explicitly (same clamp as the resolver)
+ // so a re-read never has to guess the default.
+ heroVisible: layout.heroVisible !== false,
};
}
diff --git a/src/lib/dashboard/__tests__/meds-today.test.ts b/src/lib/dashboard/__tests__/meds-today.test.ts
new file mode 100644
index 000000000..8d738d11a
--- /dev/null
+++ b/src/lib/dashboard/__tests__/meds-today.test.ts
@@ -0,0 +1,333 @@
+/**
+ * `buildMedsTodayBlock` — integration-style unit tests with a mocked
+ * Prisma client and a mocked projector.
+ *
+ * Pinned contracts:
+ * - the idempotent projection runs BEFORE the today-window read (so
+ * the tally always sees the freshly minted pending rows) with the
+ * user's local-day bounds;
+ * - the tally semantics match the summary route's compliance tile
+ * exactly (taken = `takenAt` set and not skipped);
+ * - the next-due pick is the EARLIEST display-due across active
+ * medications (real recurrence engine, no engine mocks);
+ * - an open overdue slot surfaces with `nextDueOverdue: true` and a
+ * resolved slot at the same anchor advances to the next future one;
+ * - the today window is computed in the USER's timezone (asserted on
+ * the where-clause bounds for a non-European zone).
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+const projectTodayIntakesAndRecompute = vi.fn();
+
+vi.mock("@/lib/medications/scheduling/project-today-intakes", () => ({
+ projectTodayIntakesAndRecompute: (...a: unknown[]) =>
+ projectTodayIntakesAndRecompute(...a),
+}));
+
+import { buildMedsTodayBlock } from "../meds-today";
+
+/** Noon Berlin (CEST) on a fixed summer day. */
+const NOW = new Date("2026-06-10T10:00:00.000Z");
+const BERLIN = "Europe/Berlin";
+
+interface FakeIntakeRow {
+ medicationId?: string;
+ scheduledFor?: Date;
+ takenAt: Date | null;
+ skipped: boolean;
+}
+
+function dailySchedule(
+ overrides: Record = {},
+): Record {
+ return {
+ id: "sched-1",
+ medicationId: "med-1",
+ windowStart: "08:00",
+ windowEnd: "09:00",
+ daysOfWeek: null,
+ timesOfDay: ["08:00"],
+ reminderGraceMinutes: null,
+ rrule: "FREQ=DAILY",
+ rollingIntervalDays: null,
+ scheduleType: "SCHEDULED",
+ cyclicOnWeeks: null,
+ cyclicOffWeeks: null,
+ doseWindows: null,
+ ...overrides,
+ };
+}
+
+function medication(
+ overrides: Record = {},
+): Record {
+ return {
+ id: "med-1",
+ name: "Testmittel",
+ startsOn: null,
+ endsOn: null,
+ oneShot: false,
+ createdAt: new Date("2026-01-01T00:00:00.000Z"),
+ schedules: [dailySchedule()],
+ ...overrides,
+ };
+}
+
+/** Call-order ledger so the projection-before-read contract is assertable. */
+let callOrder: string[];
+let medications: Array>;
+let todayRows: FakeIntakeRow[];
+let resolvedRows: Array<{
+ medicationId: string;
+ scheduledFor: Date;
+ takenAt: Date | null;
+}>;
+let latestIntakeGroups: Array<{
+ medicationId: string;
+ _max: { takenAt: Date | null };
+}>;
+let eraFloorGroups: Array<{
+ medicationId: string;
+ _max: { validUntil: Date | null };
+}>;
+let capturedTodayWhere: Record | null;
+
+const fakePrisma = {
+ medication: {
+ findMany: vi.fn(async () => {
+ callOrder.push("medication.findMany");
+ return medications;
+ }),
+ },
+ medicationIntakeEvent: {
+ findMany: vi.fn(
+ async (args: { where: { OR?: unknown; scheduledFor?: unknown } }) => {
+ if (args.where.OR) {
+ callOrder.push("resolved.findMany");
+ return resolvedRows;
+ }
+ callOrder.push("today.findMany");
+ capturedTodayWhere = args.where as Record;
+ return todayRows;
+ },
+ ),
+ groupBy: vi.fn(async () => {
+ callOrder.push("latest.groupBy");
+ return latestIntakeGroups;
+ }),
+ },
+ medicationScheduleRevision: {
+ groupBy: vi.fn(async () => {
+ callOrder.push("era.groupBy");
+ return eraFloorGroups;
+ }),
+ },
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+} as any;
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ callOrder = [];
+ medications = [];
+ todayRows = [];
+ resolvedRows = [];
+ latestIntakeGroups = [];
+ eraFloorGroups = [];
+ capturedTodayWhere = null;
+ projectTodayIntakesAndRecompute.mockImplementation(async () => {
+ callOrder.push("project");
+ return { projected: 0, backfilled: 0 };
+ });
+});
+
+describe("buildMedsTodayBlock — projection contract", () => {
+ it("projects the user's local today BEFORE every read (idempotency seam)", async () => {
+ await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+
+ expect(projectTodayIntakesAndRecompute).toHaveBeenCalledTimes(1);
+ const arg = projectTodayIntakesAndRecompute.mock.calls[0][0] as {
+ userId: string;
+ userTz: string;
+ todayStart: Date;
+ todayEnd: Date;
+ };
+ expect(arg.userId).toBe("user-1");
+ expect(arg.userTz).toBe(BERLIN);
+ // Berlin local midnight (CEST = UTC+2) → 22:00Z the prior evening.
+ expect(arg.todayStart.toISOString()).toBe("2026-06-09T22:00:00.000Z");
+ expect(arg.todayEnd.toISOString()).toBe("2026-06-10T22:00:00.000Z");
+
+ // Projection strictly first — the tally must see the minted rows.
+ expect(callOrder[0]).toBe("project");
+ expect(callOrder.slice(1)).toContain("today.findMany");
+ });
+
+ it("computes the today window in the user's zone, not the server's", async () => {
+ // Pacific/Auckland (UTC+12, no DST in June): 10:00Z = 22:00 local,
+ // so local-today spans [2026-06-09T12:00Z, 2026-06-10T12:00Z).
+ await buildMedsTodayBlock(fakePrisma, "user-1", "Pacific/Auckland", NOW);
+
+ const where = capturedTodayWhere as {
+ scheduledFor: { gte: Date; lt: Date };
+ deletedAt: null;
+ };
+ expect(where.scheduledFor.gte.toISOString()).toBe(
+ "2026-06-09T12:00:00.000Z",
+ );
+ expect(where.scheduledFor.lt.toISOString()).toBe(
+ "2026-06-10T12:00:00.000Z",
+ );
+ expect(where.deletedAt).toBeNull();
+ });
+});
+
+describe("buildMedsTodayBlock — tally", () => {
+ it("counts scheduled / taken / skipped with the summary-tile semantics", async () => {
+ todayRows = [
+ { takenAt: new Date("2026-06-10T06:05:00.000Z"), skipped: false },
+ { takenAt: new Date("2026-06-10T08:00:00.000Z"), skipped: false },
+ { takenAt: null, skipped: true }, // deliberate skip
+ { takenAt: null, skipped: false }, // still-open pending
+ ];
+
+ const block = await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+
+ expect(block.scheduledToday).toBe(4);
+ expect(block.takenToday).toBe(2);
+ expect(block.skippedToday).toBe(1);
+ });
+
+ it("returns a zeroed block for an account with no medications", async () => {
+ const block = await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+ expect(block).toEqual({
+ activeCount: 0,
+ scheduledToday: 0,
+ takenToday: 0,
+ skippedToday: 0,
+ nextDueAt: null,
+ nextDueOverdue: false,
+ nextDueMedicationName: null,
+ });
+ });
+
+ it("reads only ACTIVE medications", async () => {
+ await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+ const arg = fakePrisma.medication.findMany.mock.calls[0][0] as {
+ where: { userId: string; active: boolean };
+ };
+ expect(arg.where).toEqual({ userId: "user-1", active: true });
+ });
+});
+
+describe("buildMedsTodayBlock — next due (real engine)", () => {
+ it("picks the EARLIEST future slot across medications, with its name", async () => {
+ // 18:00 Berlin = 16:00Z; 20:00 Berlin = 18:00Z. Yesterday's slots
+ // are past their catch-up bands (daily tail 4 h), so the engine
+ // lands on today's anchors.
+ medications = [
+ medication({
+ id: "med-late",
+ name: "Spätmittel",
+ schedules: [
+ dailySchedule({
+ id: "sched-late",
+ medicationId: "med-late",
+ windowStart: "20:00",
+ windowEnd: "21:00",
+ timesOfDay: ["20:00"],
+ }),
+ ],
+ }),
+ medication({
+ id: "med-evening",
+ name: "Abendmittel",
+ schedules: [
+ dailySchedule({
+ id: "sched-evening",
+ medicationId: "med-evening",
+ windowStart: "18:00",
+ windowEnd: "19:00",
+ timesOfDay: ["18:00"],
+ }),
+ ],
+ }),
+ ];
+
+ const block = await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+
+ expect(block.activeCount).toBe(2);
+ expect(block.nextDueAt).toBe("2026-06-10T16:00:00.000Z");
+ expect(block.nextDueOverdue).toBe(false);
+ expect(block.nextDueMedicationName).toBe("Abendmittel");
+ });
+
+ it("surfaces an open overdue slot (anchor passed, band still open)", async () => {
+ // 11:00 Berlin anchor = 09:00Z; now is 12:00 Berlin — one hour past
+ // the anchor, well inside the daily 4 h catch-up band.
+ medications = [
+ medication({
+ name: "Mittagsmittel",
+ schedules: [
+ dailySchedule({
+ windowStart: "11:00",
+ windowEnd: "12:00",
+ timesOfDay: ["11:00"],
+ }),
+ ],
+ }),
+ ];
+
+ const block = await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+
+ expect(block.nextDueAt).toBe("2026-06-10T09:00:00.000Z");
+ expect(block.nextDueOverdue).toBe(true);
+ expect(block.nextDueMedicationName).toBe("Mittagsmittel");
+ });
+
+ it("advances past a RESOLVED slot to the next future anchor", async () => {
+ medications = [
+ medication({
+ name: "Mittagsmittel",
+ schedules: [
+ dailySchedule({
+ windowStart: "11:00",
+ windowEnd: "12:00",
+ timesOfDay: ["11:00"],
+ }),
+ ],
+ }),
+ ];
+ // The 11:00-Berlin slot was acted on — taken row at the anchor.
+ resolvedRows = [
+ {
+ medicationId: "med-1",
+ scheduledFor: new Date("2026-06-10T09:00:00.000Z"),
+ // Slot-anchored take (attributed): takenAt differs from the anchor.
+ takenAt: new Date("2026-06-10T09:05:00.000Z"),
+ },
+ ];
+
+ const block = await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+
+ // Tomorrow's 11:00 Berlin anchor.
+ expect(block.nextDueAt).toBe("2026-06-11T09:00:00.000Z");
+ expect(block.nextDueOverdue).toBe(false);
+ });
+
+ it("returns null next-due when no schedule has an upcoming slot", async () => {
+ // Course ended last month — the engine yields nothing.
+ medications = [
+ medication({
+ name: "Altmittel",
+ endsOn: new Date("2026-05-01T00:00:00.000Z"),
+ }),
+ ];
+
+ const block = await buildMedsTodayBlock(fakePrisma, "user-1", BERLIN, NOW);
+
+ expect(block.activeCount).toBe(1);
+ expect(block.nextDueAt).toBeNull();
+ expect(block.nextDueOverdue).toBe(false);
+ expect(block.nextDueMedicationName).toBeNull();
+ });
+});
diff --git a/src/lib/dashboard/__tests__/snapshot.test.ts b/src/lib/dashboard/__tests__/snapshot.test.ts
index 991e3dcc8..ef9da94e1 100644
--- a/src/lib/dashboard/__tests__/snapshot.test.ts
+++ b/src/lib/dashboard/__tests__/snapshot.test.ts
@@ -21,6 +21,8 @@ const ensureUserMoodRollupsFresh = vi.fn();
const computeBpInTargetFastPath = vi.fn();
const getAssistantFlags = vi.fn();
const hasAnyConfiguredProvider = vi.fn();
+const buildMedsTodayBlock = vi.fn();
+const computeUserHealthScoreFastPath = vi.fn();
vi.mock("@/lib/analytics/summaries-slice", () => ({
computeSummariesSlice: (...a: unknown[]) => computeSummariesSlice(...a),
@@ -46,6 +48,15 @@ vi.mock("@/lib/feature-flags", () => ({
vi.mock("@/lib/ai/provider", () => ({
hasAnyConfiguredProvider: (...a: unknown[]) => hasAnyConfiguredProvider(...a),
}));
+// Meds-today + health-score builders are tested in their own suites;
+// here only the assembly contract (fast vs warm phase) is pinned.
+vi.mock("@/lib/dashboard/meds-today", () => ({
+ buildMedsTodayBlock: (...a: unknown[]) => buildMedsTodayBlock(...a),
+}));
+vi.mock("@/lib/analytics/health-score-fast-path", () => ({
+ computeUserHealthScoreFastPath: (...a: unknown[]) =>
+ computeUserHealthScoreFastPath(...a),
+}));
import {
buildDashboardSnapshot,
@@ -112,6 +123,16 @@ beforeEach(() => {
fakePrisma.measurement.findMany.mockResolvedValue([]);
fakePrisma.moodEntry.findMany.mockResolvedValue([]);
hasAnyConfiguredProvider.mockResolvedValue(true);
+ buildMedsTodayBlock.mockResolvedValue({
+ activeCount: 1,
+ scheduledToday: 2,
+ takenToday: 1,
+ skippedToday: 0,
+ nextDueAt: null,
+ nextDueOverdue: false,
+ nextDueMedicationName: null,
+ });
+ computeUserHealthScoreFastPath.mockResolvedValue(null);
});
describe("buildDashboardSnapshot — envelope shape", () => {
@@ -195,6 +216,104 @@ describe("buildDashboardSnapshot — two-phase null extras", () => {
});
});
+describe("buildDashboardSnapshot — medsToday (fast phase)", () => {
+ it("rides the fast phase and is present even on a rollup-coverage miss", async () => {
+ probeRollupCoverage.mockResolvedValue(new Map([["WEIGHT", false]]));
+ isFullyCovered.mockReturnValue(false);
+
+ const snap = await buildDashboardSnapshot(fakePrisma, baseUser());
+
+ expect(snap.medsToday).toEqual({
+ activeCount: 1,
+ scheduledToday: 2,
+ takenToday: 1,
+ skippedToday: 0,
+ nextDueAt: null,
+ nextDueOverdue: false,
+ nextDueMedicationName: null,
+ });
+ // Built from the user's id + timezone, not from any body field.
+ expect(buildMedsTodayBlock).toHaveBeenCalledWith(
+ fakePrisma,
+ "user-1",
+ "Europe/Berlin",
+ expect.any(Date),
+ );
+ });
+});
+
+describe("buildDashboardSnapshot — healthScore (warm phase only)", () => {
+ it("is null on a rollup-coverage miss and the fast path never runs", async () => {
+ probeRollupCoverage.mockResolvedValue(new Map([["WEIGHT", false]]));
+ isFullyCovered.mockReturnValue(false);
+
+ const snap = await buildDashboardSnapshot(fakePrisma, baseUser());
+
+ expect(snap.healthScore).toBeNull();
+ expect(computeUserHealthScoreFastPath).not.toHaveBeenCalled();
+ });
+
+ it("serialises score + band + delta — and ONLY those — when warm", async () => {
+ const coverageMap = new Map([["WEIGHT", true]]);
+ probeRollupCoverage.mockResolvedValue(coverageMap);
+ isFullyCovered.mockReturnValue(true);
+ computeBpInTargetFastPath.mockResolvedValue({
+ last7Days: { pct: 70 },
+ last30Days: { pct: 80 },
+ allTime: { pct: 75 },
+ priorMonth: { pct: 60 },
+ priorYear: { pct: 50 },
+ gradedScore: 88,
+ });
+ computeUserHealthScoreFastPath.mockResolvedValue({
+ score: 72,
+ band: "yellow",
+ delta: -12,
+ components: { bp: {}, weight: {}, mood: {}, compliance: {} },
+ });
+
+ const snap = await buildDashboardSnapshot(fakePrisma, baseUser());
+
+ // Score + band + delta only — components never reach the wire.
+ expect(snap.healthScore).toEqual({ score: 72, band: "yellow", delta: -12 });
+
+ // The fast path reuses the BP windows + coverage map already
+ // computed for `extras` (no re-probe, graded score threaded).
+ expect(computeUserHealthScoreFastPath).toHaveBeenCalledTimes(1);
+ const arg = computeUserHealthScoreFastPath.mock.calls[0][0] as {
+ userId: string;
+ bpInTargetPct: number | null;
+ bpGradedScore: number | null;
+ heightCm: number | null;
+ coverage: unknown;
+ };
+ expect(arg.userId).toBe("user-1");
+ expect(arg.bpInTargetPct).toBe(80);
+ expect(arg.bpGradedScore).toBe(88);
+ expect(arg.heightCm).toBe(180);
+ expect(arg.coverage).toBe(coverageMap);
+ });
+
+ it("is null when warm but no pillar is computable (fast path returns null)", async () => {
+ probeRollupCoverage.mockResolvedValue(new Map([["WEIGHT", true]]));
+ isFullyCovered.mockReturnValue(true);
+ computeBpInTargetFastPath.mockResolvedValue({
+ last7Days: null,
+ last30Days: null,
+ allTime: null,
+ priorMonth: null,
+ priorYear: null,
+ gradedScore: null,
+ });
+ computeUserHealthScoreFastPath.mockResolvedValue(null);
+
+ const snap = await buildDashboardSnapshot(fakePrisma, baseUser());
+
+ expect(snap.extras).not.toBeNull();
+ expect(snap.healthScore).toBeNull();
+ });
+});
+
describe("buildDashboardSnapshot — briefingState matrix", () => {
beforeEach(() => {
probeRollupCoverage.mockResolvedValue(new Map());
@@ -507,6 +626,8 @@ describe("buildDashboardSnapshot — additive proof", () => {
expect(snap).toHaveProperty("metricStates");
expect(snap).toHaveProperty("layoutCatalogue");
expect(snap).toHaveProperty("briefingStale");
+ expect(snap).toHaveProperty("medsToday");
+ expect(snap).toHaveProperty("healthScore");
// The web-consumed `layout` block is the resolved per-user layout —
// NOT replaced by the 35-id catalogue.
diff --git a/src/lib/dashboard/__tests__/verdict-client-safety.test.ts b/src/lib/dashboard/__tests__/verdict-client-safety.test.ts
new file mode 100644
index 000000000..199f80bb8
--- /dev/null
+++ b/src/lib/dashboard/__tests__/verdict-client-safety.test.ts
@@ -0,0 +1,134 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+
+/**
+ * Client-safety pin for the verdict resolver's import graph.
+ *
+ * `resolveDashboardVerdict` runs inside the `"use client"` dashboard
+ * hero, so every VALUE import reachable from `verdict.ts` must stay off
+ * the server graph: no prisma, no `node:` builtins, no pg-boss, no
+ * `@/lib/jobs/coach-nudge` (whose dispatcher/feature-flag imports pull
+ * `node:async_hooks` — the exact regression class the dose-window
+ * editor hit when it imported `DOSE_WINDOW_DEFAULTS` from
+ * `@/lib/analytics/compliance`; see
+ * `src/lib/medications/scheduling/dose-window-defaults.ts`). The shared
+ * nudge thresholds therefore live in the dependency-free
+ * `@/lib/jobs/coach-nudge-thresholds` leaf.
+ *
+ * `import type` statements are erased by the compiler AND the bundler,
+ * so the walker skips them — the `DashboardSnapshot` type import from
+ * `@/lib/dashboard/snapshot` (a heavy server module) is legal exactly
+ * as long as it stays type-only. If someone drops the `type` keyword,
+ * the walker traverses into the snapshot builder and this suite fails.
+ */
+
+const SRC = join(process.cwd(), "src");
+const ENTRY = join(SRC, "lib/dashboard/verdict.ts");
+
+/** Specifier patterns that mark a server-only dependency. */
+const BANNED_SPECIFIERS: RegExp[] = [
+ /^node:/,
+ /^@\/generated\//,
+ /^@\/lib\/db$/,
+ /^@prisma\//,
+ /^pg-boss$/,
+ /^server-only$/,
+ /^@\/lib\/jobs\/coach-nudge$/,
+];
+
+/**
+ * Extract VALUE-import specifiers from a module. Type-only statements
+ * (`import type … from`, `export type … from`) are erased at build
+ * time and skipped. Side-effect imports (`import "x"`) are included.
+ */
+function valueImportSpecifiers(source: string): string[] {
+ const out: string[] = [];
+ // Statement-anchored (`^import` / `^export`) and semicolon-bounded
+ // (`[^;]*?`) so the lazy scan can never swallow across statements or
+ // latch onto a `from "…"` inside an unrelated string / comment.
+ const stmt =
+ /^(import|export)(\s+type)?\s+[^;"']*?from\s*["']([^"']+)["']|^import\s*["']([^"']+)["']/gm;
+ let m: RegExpExecArray | null;
+ while ((m = stmt.exec(source)) !== null) {
+ if (m[4] !== undefined) {
+ out.push(m[4]); // bare side-effect import
+ continue;
+ }
+ if (m[2] !== undefined) continue; // `import type` / `export type` — erased
+ out.push(m[3]);
+ }
+ return out;
+}
+
+/** Resolve `@/…` and relative specifiers to a file inside `src/`. */
+function resolveLocal(spec: string, fromFile: string): string | null {
+ let base: string;
+ if (spec.startsWith("@/")) base = join(SRC, spec.slice(2));
+ else if (spec.startsWith(".")) base = resolve(dirname(fromFile), spec);
+ else return null; // external package
+ for (const candidate of [
+ base,
+ `${base}.ts`,
+ `${base}.tsx`,
+ join(base, "index.ts"),
+ join(base, "index.tsx"),
+ ]) {
+ if (existsSync(candidate) && statSync(candidate).isFile()) {
+ return candidate;
+ }
+ }
+ throw new Error(`unresolvable local import "${spec}" from ${fromFile}`);
+}
+
+function walkGraph(entry: string): {
+ visited: Set;
+ specifiers: Set;
+} {
+ const visited = new Set();
+ const specifiers = new Set();
+ const queue = [entry];
+ while (queue.length > 0) {
+ const file = queue.pop()!;
+ if (visited.has(file)) continue;
+ visited.add(file);
+ for (const spec of valueImportSpecifiers(readFileSync(file, "utf8"))) {
+ specifiers.add(spec);
+ const local = resolveLocal(spec, file);
+ if (local !== null) queue.push(local);
+ }
+ }
+ return { visited, specifiers };
+}
+
+describe("verdict.ts — client-safe import graph", () => {
+ const { visited, specifiers } = walkGraph(ENTRY);
+
+ it("carries no server-only specifier anywhere in the value-import graph", () => {
+ const offenders = [...specifiers].filter((spec) =>
+ BANNED_SPECIFIERS.some((re) => re.test(spec)),
+ );
+ expect(offenders).toEqual([]);
+ });
+
+ it("never traverses into the snapshot builder (type-only boundary holds)", () => {
+ const snapshotModule = join(SRC, "lib/dashboard/snapshot.ts");
+ expect(visited.has(snapshotModule)).toBe(false);
+ });
+
+ it("reads the nudge thresholds from the dependency-free leaf", () => {
+ expect(specifiers.has("@/lib/jobs/coach-nudge-thresholds")).toBe(true);
+ const leaf = readFileSync(
+ join(SRC, "lib/jobs/coach-nudge-thresholds.ts"),
+ "utf8",
+ );
+ expect(valueImportSpecifiers(leaf)).toEqual([]);
+ });
+
+ it("the whole graph stays local — no external runtime package rides in", () => {
+ const external = [...specifiers].filter(
+ (spec) => !spec.startsWith("@/") && !spec.startsWith("."),
+ );
+ expect(external).toEqual([]);
+ });
+});
diff --git a/src/lib/dashboard/__tests__/verdict.test.ts b/src/lib/dashboard/__tests__/verdict.test.ts
new file mode 100644
index 000000000..c5f704c19
--- /dev/null
+++ b/src/lib/dashboard/__tests__/verdict.test.ts
@@ -0,0 +1,705 @@
+/**
+ * Dashboard hero — verdict-ladder unit tests.
+ *
+ * `resolveDashboardVerdict` is pure (snapshot in, verdict out, `now`
+ * injected), so the suite pins every rung, the first-hit-wins
+ * precedence, and the exact boundaries the spec locked:
+ * - bpCritical fires at sys 180, not 179 (fixed floors, never user
+ * thresholds), only on a fresh reading, and outranks an overdue
+ * dose (a crisis-level reading is rung 1);
+ * - weightDrift fires at a 0.50 kg distance delta, not 0.49;
+ * - silence fires at 7 days, not 6;
+ * - scoreDrop fires at −10, not −9;
+ * - doseUpcoming is timezone-correct (next anchor must be today in
+ * the USER's zone) and never fires on a stale past `nextDueAt`
+ * with `nextDueOverdue: false` (the cached-snapshot defensive
+ * contract).
+ */
+import { describe, it, expect } from "vitest";
+
+import { resolveDashboardVerdict } from "../verdict";
+import type { DashboardSnapshot } from "../snapshot";
+import type { MedsTodayBlock } from "../meds-today";
+import type { DataSummary } from "@/lib/analytics/trends";
+
+/** Noon Berlin (CEST) on a fixed summer day. */
+const NOW = new Date("2026-06-10T10:00:00.000Z");
+
+function summary(partial: Partial): DataSummary {
+ return {
+ count: 0,
+ latest: null,
+ min: null,
+ max: null,
+ mean: null,
+ median: null,
+ avg7: null,
+ avg30: null,
+ slope7: null,
+ slope30: null,
+ slope90: null,
+ anomalyCount: 0,
+ ...partial,
+ };
+}
+
+function medsToday(partial: Partial = {}): MedsTodayBlock {
+ return {
+ activeCount: 0,
+ scheduledToday: 0,
+ takenToday: 0,
+ skippedToday: 0,
+ nextDueAt: null,
+ nextDueOverdue: false,
+ nextDueMedicationName: null,
+ ...partial,
+ };
+}
+
+function baseSnapshot(
+ overrides: Partial = {},
+): DashboardSnapshot {
+ return {
+ user: {
+ username: "tester",
+ timezone: "Europe/Berlin",
+ heightCm: null,
+ dateOfBirth: null,
+ gender: null,
+ glucoseUnit: null,
+ onboardingTourCompleted: true,
+ greetingHour: 12,
+ },
+ layout: { version: 1, widgets: [] },
+ layoutCatalogue: [],
+ metricStates: {},
+ tiles: {
+ summaries: {},
+ lastSeenByType: {},
+ mood: { summary: null, entries: [] },
+ },
+ extras: null,
+ medsToday: medsToday(),
+ healthScore: null,
+ briefing: null,
+ briefingState: "preparing",
+ briefingUpdatedAt: null,
+ briefingStale: false,
+ generatedAt: NOW.toISOString(),
+ ...overrides,
+ };
+}
+
+function isoHoursAgo(hours: number, now: Date = NOW): string {
+ return new Date(now.getTime() - hours * 60 * 60 * 1000).toISOString();
+}
+
+const FRESH_FINDING = {
+ tone: "info" as const,
+ headline: "Steps held steady this week.",
+ detail: "Daily totals stayed within the usual range.",
+ delta: null,
+ sourceWindow: "7d" as const,
+ sourceMetric: "steps" as const,
+};
+
+const WATCH_FINDING = {
+ tone: "watch" as const,
+ headline: "Systolic crept up over seven days.",
+ detail: "The weekly mean sits above the prior week.",
+ delta: "+4 mmHg",
+ sourceWindow: "7d" as const,
+ sourceMetric: "bp" as const,
+};
+
+describe("rung 2 — doseOverdue", () => {
+ it("fires on nextDueOverdue with the medication name and a quick-entry CTA", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ medsToday: medsToday({
+ scheduledToday: 2,
+ nextDueAt: isoHoursAgo(1),
+ nextDueOverdue: true,
+ nextDueMedicationName: "Metformin",
+ }),
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("doseOverdue");
+ expect(verdict.values).toEqual({ name: "Metformin" });
+ expect(verdict.cta).toEqual({
+ kind: "quickEntry",
+ target: "medicationIntake",
+ });
+ });
+
+ it("yields to a simultaneously critical fresh BP reading (precedence)", () => {
+ // A crisis-level reading (≥ 180 / ≥ 110, ≤ 1 day old) is rung 1 —
+ // it must not hide behind a routine medication prompt.
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ medsToday: medsToday({
+ nextDueOverdue: true,
+ nextDueMedicationName: "Metformin",
+ }),
+ tiles: {
+ summaries: {
+ BLOOD_PRESSURE_SYS: summary({ latest: 200, count: 5 }),
+ BLOOD_PRESSURE_DIA: summary({ latest: 120, count: 5 }),
+ },
+ lastSeenByType: {
+ BLOOD_PRESSURE_SYS: { lastSeenAt: isoHoursAgo(1), daysAgo: 0 },
+ },
+ mood: { summary: null, entries: [] },
+ },
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("bpCritical");
+ });
+
+ it("wins over the BP rung once the critical reading has aged past a day", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ medsToday: medsToday({
+ nextDueOverdue: true,
+ nextDueMedicationName: "Metformin",
+ }),
+ tiles: {
+ summaries: {
+ BLOOD_PRESSURE_SYS: summary({ latest: 200, count: 5 }),
+ BLOOD_PRESSURE_DIA: summary({ latest: 120, count: 5 }),
+ },
+ lastSeenByType: {
+ BLOOD_PRESSURE_SYS: { lastSeenAt: isoHoursAgo(3 * 24), daysAgo: 3 },
+ },
+ mood: { summary: null, entries: [] },
+ },
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("doseOverdue");
+ });
+
+ it("never renders overdue from a stale past nextDueAt with the flag false", () => {
+ // Cached-snapshot defensive contract: the anchor passed AFTER the
+ // snapshot was built, so the flag is still false — plain summary.
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ medsToday: medsToday({
+ scheduledToday: 1,
+ nextDueAt: isoHoursAgo(1),
+ nextDueOverdue: false,
+ nextDueMedicationName: "Metformin",
+ }),
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+});
+
+describe("rung 1 — bpCritical", () => {
+ function bpSnapshot(
+ sys: number | null,
+ dia: number | null,
+ lastSeenAt: string,
+ ): DashboardSnapshot {
+ return baseSnapshot({
+ tiles: {
+ summaries: {
+ ...(sys !== null && {
+ BLOOD_PRESSURE_SYS: summary({ latest: sys, count: 5 }),
+ }),
+ ...(dia !== null && {
+ BLOOD_PRESSURE_DIA: summary({ latest: dia, count: 5 }),
+ }),
+ },
+ lastSeenByType: {
+ BLOOD_PRESSURE_SYS: { lastSeenAt, daysAgo: 0 },
+ },
+ mood: { summary: null, entries: [] },
+ },
+ });
+ }
+
+ it("fires at the fixed systolic floor 180 with a fresh reading", () => {
+ const verdict = resolveDashboardVerdict(
+ bpSnapshot(180, 95, isoHoursAgo(2)),
+ NOW,
+ );
+ expect(verdict.variant).toBe("bpCritical");
+ expect(verdict.values).toEqual({ sys: 180, dia: 95 });
+ expect(verdict.cta).toEqual({
+ kind: "link",
+ href: "/insights/blood-pressure",
+ });
+ });
+
+ it("does NOT fire at 179 (boundary)", () => {
+ const verdict = resolveDashboardVerdict(
+ bpSnapshot(179, 95, isoHoursAgo(2)),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("fires on the diastolic floor 110 alone", () => {
+ const verdict = resolveDashboardVerdict(
+ bpSnapshot(150, 110, isoHoursAgo(2)),
+ NOW,
+ );
+ expect(verdict.variant).toBe("bpCritical");
+ expect(verdict.values).toEqual({ sys: 150, dia: 110 });
+ });
+
+ it("does NOT fire at dia 109 (boundary)", () => {
+ const verdict = resolveDashboardVerdict(
+ bpSnapshot(150, 109, isoHoursAgo(2)),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("skips a critical-valued reading older than one day", () => {
+ const verdict = resolveDashboardVerdict(
+ bpSnapshot(190, 120, isoHoursAgo(3 * 24)),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("still fires inside the one-day freshness window (daysAgo floor 1)", () => {
+ const verdict = resolveDashboardVerdict(
+ bpSnapshot(190, 120, isoHoursAgo(36)),
+ NOW,
+ );
+ expect(verdict.variant).toBe("bpCritical");
+ });
+
+ it("re-derives freshness from the injected now, not the snapshot daysAgo", () => {
+ // The snapshot claims daysAgo: 0 (computed at build time), but the
+ // injected `now` sits three days later — the rung must skip.
+ const snap = bpSnapshot(190, 120, isoHoursAgo(1));
+ const later = new Date(NOW.getTime() + 3 * 24 * 60 * 60 * 1000);
+ expect(resolveDashboardVerdict(snap, later).variant).toBe("allQuiet");
+ // Same snapshot evaluated at its build instant fires.
+ expect(resolveDashboardVerdict(snap, NOW).variant).toBe("bpCritical");
+ });
+});
+
+describe("rung 3 — doseUpcoming", () => {
+ function upcomingSnapshot(
+ nextDueAt: string,
+ tz = "Europe/Berlin",
+ ): DashboardSnapshot {
+ const snap = baseSnapshot({
+ medsToday: medsToday({
+ scheduledToday: 2,
+ takenToday: 1,
+ skippedToday: 0,
+ nextDueAt,
+ nextDueOverdue: false,
+ nextDueMedicationName: "Ramipril",
+ }),
+ });
+ snap.user.timezone = tz;
+ return snap;
+ }
+
+ it("fires for a dose due within two hours today, with local HH:mm", () => {
+ // 11:30 UTC = 13:30 Berlin (CEST).
+ const verdict = resolveDashboardVerdict(
+ upcomingSnapshot("2026-06-10T11:30:00.000Z"),
+ NOW,
+ );
+ expect(verdict.variant).toBe("doseUpcoming");
+ expect(verdict.values).toEqual({ time: "13:30", name: "Ramipril" });
+ expect(verdict.cta).toEqual({
+ kind: "quickEntry",
+ target: "medicationIntake",
+ });
+ });
+
+ it("does NOT fire when the dose is more than two hours away", () => {
+ const verdict = resolveDashboardVerdict(
+ upcomingSnapshot("2026-06-10T12:30:00.000Z"),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("fires exactly at the two-hour boundary", () => {
+ const verdict = resolveDashboardVerdict(
+ upcomingSnapshot("2026-06-10T12:00:00.000Z"),
+ NOW,
+ );
+ expect(verdict.variant).toBe("doseUpcoming");
+ });
+
+ it("does NOT fire when the next anchor falls on tomorrow in the user's zone", () => {
+ // 23:30 Berlin: a dose 1 h away sits at 00:30 LOCAL tomorrow even
+ // though it is still 2026-06-10 in UTC terms of distance.
+ const lateNow = new Date("2026-06-10T21:30:00.000Z"); // 23:30 Berlin
+ const verdict = resolveDashboardVerdict(
+ upcomingSnapshot("2026-06-10T22:30:00.000Z"),
+ lateNow,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("respects a non-European zone for the same instants", () => {
+ // Pacific/Auckland (UTC+12, no DST in June): 10:00 UTC = 22:00
+ // local; a dose at 11:30 UTC = 23:30 local is still TODAY there.
+ const verdict = resolveDashboardVerdict(
+ upcomingSnapshot("2026-06-10T11:30:00.000Z", "Pacific/Auckland"),
+ NOW,
+ );
+ expect(verdict.variant).toBe("doseUpcoming");
+ expect(verdict.values).toEqual({ time: "23:30", name: "Ramipril" });
+ });
+
+ it("does NOT fire when every scheduled dose is already resolved", () => {
+ const snap = upcomingSnapshot("2026-06-10T11:30:00.000Z");
+ snap.medsToday.takenToday = 1;
+ snap.medsToday.skippedToday = 1; // 2 scheduled, 2 resolved
+ expect(resolveDashboardVerdict(snap, NOW).variant).toBe("allQuiet");
+ });
+});
+
+describe("rung 4 — weightDrift", () => {
+ // height 180 cm → green band [59.94, 80.676] kg.
+ const GREEN_MAX_180 = 24.9 * 1.8 * 1.8;
+
+ function weightSnapshot(
+ avg7: number | null,
+ avg30: number | null,
+ heightCm: number | null = 180,
+ ): DashboardSnapshot {
+ const snap = baseSnapshot({
+ tiles: {
+ summaries: {
+ WEIGHT: summary({ latest: avg7, avg7, avg30, count: 20 }),
+ },
+ lastSeenByType: {
+ WEIGHT: { lastSeenAt: isoHoursAgo(2), daysAgo: 0 },
+ },
+ mood: { summary: null, entries: [] },
+ },
+ });
+ snap.user.heightCm = heightCm;
+ return snap;
+ }
+
+ it("fires at exactly the 0.50 kg drift threshold", () => {
+ // avg30 inside the band (distance 0), avg7 exactly 0.5 kg outside.
+ const verdict = resolveDashboardVerdict(
+ weightSnapshot(GREEN_MAX_180 + 0.5, GREEN_MAX_180 - 1),
+ NOW,
+ );
+ expect(verdict.variant).toBe("weightDrift");
+ expect(verdict.cta).toEqual({ kind: "link", href: "/insights/weight" });
+ });
+
+ it("does NOT fire at 0.49 kg drift (boundary)", () => {
+ const verdict = resolveDashboardVerdict(
+ weightSnapshot(GREEN_MAX_180 + 0.49, GREEN_MAX_180 - 1),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("skips entirely when no height is stored (no derivable range)", () => {
+ const verdict = resolveDashboardVerdict(
+ weightSnapshot(GREEN_MAX_180 + 5, GREEN_MAX_180 - 1, null),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("skips when avg7 or avg30 is null", () => {
+ expect(resolveDashboardVerdict(weightSnapshot(null, 75), NOW).variant).toBe(
+ "allQuiet",
+ );
+ expect(
+ resolveDashboardVerdict(weightSnapshot(GREEN_MAX_180 + 5, null), NOW)
+ .variant,
+ ).toBe("allQuiet");
+ });
+
+ it("stays silent while converging back toward the range", () => {
+ // avg7 closer to the band than avg30 — drift is negative.
+ const verdict = resolveDashboardVerdict(
+ weightSnapshot(GREEN_MAX_180 + 1, GREEN_MAX_180 + 3),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+});
+
+describe("rung 5 — shortNights", () => {
+ function sleepSnapshot(
+ avg7: number | null,
+ count: number,
+ ): DashboardSnapshot {
+ return baseSnapshot({
+ tiles: {
+ summaries: {
+ SLEEP_DURATION: summary({ avg7, count, latest: avg7 }),
+ },
+ lastSeenByType: {
+ SLEEP_DURATION: { lastSeenAt: isoHoursAgo(8), daysAgo: 0 },
+ },
+ mood: { summary: null, entries: [] },
+ },
+ });
+ }
+
+ it("fires under the clear-margin floor (6.5 h) with enough readings", () => {
+ const verdict = resolveDashboardVerdict(sleepSnapshot(360, 7), NOW);
+ expect(verdict.variant).toBe("shortNights");
+ expect(verdict.values).toEqual({ hours: 6 });
+ expect(verdict.cta).toEqual({ kind: "link", href: "/insights/sleep" });
+ });
+
+ it("fires just under the 390-minute floor, not at it (boundary)", () => {
+ expect(resolveDashboardVerdict(sleepSnapshot(389, 7), NOW).variant).toBe(
+ "shortNights",
+ );
+ expect(resolveDashboardVerdict(sleepSnapshot(390, 7), NOW).variant).toBe(
+ "allQuiet",
+ );
+ });
+
+ it("stays silent on a sparse week (fewer than 5 readings)", () => {
+ expect(resolveDashboardVerdict(sleepSnapshot(300, 4), NOW).variant).toBe(
+ "allQuiet",
+ );
+ });
+});
+
+describe("rung 6 — silence", () => {
+ function silenceSnapshot(
+ seen: Record,
+ ): DashboardSnapshot {
+ return baseSnapshot({
+ tiles: {
+ summaries: {},
+ lastSeenByType: seen,
+ mood: { summary: null, entries: [] },
+ },
+ });
+ }
+
+ it("fires when every logged-ever core vital is silent for ≥ 7 days", () => {
+ const verdict = resolveDashboardVerdict(
+ silenceSnapshot({
+ WEIGHT: { lastSeenAt: isoHoursAgo(8 * 24), daysAgo: 8 },
+ BLOOD_PRESSURE_SYS: { lastSeenAt: isoHoursAgo(9 * 24), daysAgo: 9 },
+ // glucose never logged — excluded from the min.
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("silence");
+ expect(verdict.values).toEqual({ days: 8 });
+ expect(verdict.cta).toEqual({ kind: "quickEntry", target: "measurement" });
+ });
+
+ it("does NOT fire at 6 days (boundary), fires at exactly 7", () => {
+ expect(
+ resolveDashboardVerdict(
+ silenceSnapshot({
+ WEIGHT: { lastSeenAt: isoHoursAgo(6 * 24), daysAgo: 6 },
+ }),
+ NOW,
+ ).variant,
+ ).toBe("allQuiet");
+ expect(
+ resolveDashboardVerdict(
+ silenceSnapshot({
+ WEIGHT: { lastSeenAt: isoHoursAgo(7 * 24), daysAgo: 7 },
+ }),
+ NOW,
+ ).variant,
+ ).toBe("silence");
+ });
+
+ it("a single fresh vital silences the rung (min, not max)", () => {
+ const verdict = resolveDashboardVerdict(
+ silenceSnapshot({
+ WEIGHT: { lastSeenAt: isoHoursAgo(30 * 24), daysAgo: 30 },
+ BLOOD_GLUCOSE: { lastSeenAt: isoHoursAgo(2), daysAgo: 0 },
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("skips when none of the three vitals was ever logged", () => {
+ expect(resolveDashboardVerdict(silenceSnapshot({}), NOW).variant).toBe(
+ "allQuiet",
+ );
+ });
+});
+
+describe("rung 7 — scoreDrop", () => {
+ function scoreSnapshot(delta: number | null): DashboardSnapshot {
+ return baseSnapshot({
+ healthScore: { score: 60, band: "yellow", delta },
+ });
+ }
+
+ it("fires at a −10 delta (boundary)", () => {
+ const verdict = resolveDashboardVerdict(scoreSnapshot(-10), NOW);
+ expect(verdict.variant).toBe("scoreDrop");
+ expect(verdict.values).toEqual({ points: 10 });
+ expect(verdict.cta).toEqual({ kind: "link", href: "/insights" });
+ });
+
+ it("does NOT fire at −9 (boundary)", () => {
+ expect(resolveDashboardVerdict(scoreSnapshot(-9), NOW).variant).toBe(
+ "allQuiet",
+ );
+ });
+
+ it("skips a null delta and a null score block", () => {
+ expect(resolveDashboardVerdict(scoreSnapshot(null), NOW).variant).toBe(
+ "allQuiet",
+ );
+ expect(
+ resolveDashboardVerdict(baseSnapshot({ healthScore: null }), NOW).variant,
+ ).toBe("allQuiet");
+ });
+});
+
+describe("rung 8 — briefing", () => {
+ it("renders the first watch-tone headline verbatim from a fresh briefing", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ briefing: {
+ paragraph: "Calm day overall.",
+ keyFindings: [FRESH_FINDING, WATCH_FINDING],
+ },
+ briefingState: "ready",
+ briefingStale: false,
+ briefingUpdatedAt: NOW.toISOString(),
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("briefing");
+ expect(verdict.values).toEqual({ headline: WATCH_FINDING.headline });
+ expect(verdict.cta).toEqual({ kind: "link", href: "/insights" });
+ });
+
+ it("falls back to the first finding when no watch tone exists", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ briefing: {
+ paragraph: "Calm day overall.",
+ keyFindings: [FRESH_FINDING],
+ },
+ briefingState: "ready",
+ briefingStale: false,
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("briefing");
+ expect(verdict.values).toEqual({ headline: FRESH_FINDING.headline });
+ });
+
+ it("skips a STALE briefing even in ready-shaped delivery", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ briefing: {
+ paragraph: "Yesterday's text.",
+ keyFindings: [WATCH_FINDING],
+ },
+ briefingState: "preparing",
+ briefingStale: true,
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("skips ready + stale (belt and braces on the two flags)", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ briefing: {
+ paragraph: "Old text.",
+ keyFindings: [WATCH_FINDING],
+ },
+ briefingState: "ready",
+ briefingStale: true,
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+
+ it("skips an empty keyFindings array", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ briefing: { paragraph: "Flat data day.", keyFindings: [] },
+ briefingState: "ready",
+ briefingStale: false,
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("allQuiet");
+ });
+});
+
+describe("rung 9 — allQuiet + full-ladder precedence", () => {
+ it("returns allQuiet with no CTA on an empty snapshot", () => {
+ const verdict = resolveDashboardVerdict(baseSnapshot(), NOW);
+ expect(verdict).toEqual({ variant: "allQuiet", values: {}, cta: null });
+ });
+
+ it("bpCritical outranks every lower rung when stacked", () => {
+ // BP critical + short nights + score drop + fresh briefing — the
+ // ladder must stop at rung 2.
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ tiles: {
+ summaries: {
+ BLOOD_PRESSURE_SYS: summary({ latest: 185, count: 5 }),
+ BLOOD_PRESSURE_DIA: summary({ latest: 100, count: 5 }),
+ SLEEP_DURATION: summary({ avg7: 300, count: 7 }),
+ },
+ lastSeenByType: {
+ BLOOD_PRESSURE_SYS: { lastSeenAt: isoHoursAgo(1), daysAgo: 0 },
+ SLEEP_DURATION: { lastSeenAt: isoHoursAgo(8), daysAgo: 0 },
+ },
+ mood: { summary: null, entries: [] },
+ },
+ healthScore: { score: 40, band: "red", delta: -20 },
+ briefing: {
+ paragraph: "Busy day.",
+ keyFindings: [WATCH_FINDING],
+ },
+ briefingState: "ready",
+ briefingStale: false,
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("bpCritical");
+ });
+
+ it("scoreDrop outranks the briefing teaser", () => {
+ const verdict = resolveDashboardVerdict(
+ baseSnapshot({
+ healthScore: { score: 50, band: "yellow", delta: -15 },
+ briefing: {
+ paragraph: "Busy day.",
+ keyFindings: [WATCH_FINDING],
+ },
+ briefingState: "ready",
+ briefingStale: false,
+ }),
+ NOW,
+ );
+ expect(verdict.variant).toBe("scoreDrop");
+ expect(verdict.values).toEqual({ points: 15 });
+ });
+});
diff --git a/src/lib/dashboard/meds-today.ts b/src/lib/dashboard/meds-today.ts
new file mode 100644
index 000000000..1d7745c3c
--- /dev/null
+++ b/src/lib/dashboard/meds-today.ts
@@ -0,0 +1,215 @@
+/**
+ * Today's medication block for the dashboard hero + summary tally.
+ *
+ * `buildMedsTodayBlock` is the one shared builder behind every surface
+ * that answers "how is the medication day going?":
+ *
+ * 1. **Projection** — `projectTodayIntakesAndRecompute` idempotently
+ * mints the day's pending `MedicationIntakeEvent` rows for active
+ * schedules (same helper the intake route + dashboard summary use),
+ * so the tally below never under-counts a daily med whose rows the
+ * reminder worker has not minted yet.
+ * 2. **Tally** — one today-window event read produces
+ * `scheduledToday` / `takenToday` / `skippedToday` with the exact
+ * semantics the summary route's compliance tile always had
+ * (taken = `takenAt !== null && !skipped`; tombstones excluded).
+ * 3. **Next due** — the same four feeder reads +
+ * `computeDisplayDue` loop the medications list route runs
+ * (`src/app/api/medications/route.ts`), restricted to ACTIVE
+ * medications: latest non-skipped intake per med (rolling cadences
+ * re-anchor on it), resolved slots over the overdue-lookback
+ * horizon, and the current-era floor per med. The block surfaces
+ * the EARLIEST display-due across medications — an open overdue
+ * slot sits in the past, so it naturally wins over any future slot.
+ *
+ * The feeder reads are not lifted out of the medications list route
+ * because that route reuses the same rows for its own response fields
+ * (`lastTakenAt`, `todayEventCount`, per-card next-due); the clean
+ * shared seam is `computeDisplayDue` itself, which both call sites go
+ * through.
+ *
+ * Consumer contract (snapshot caching): `nextDueAt` / `nextDueOverdue`
+ * are computed at build time and may be served from a cache. A
+ * `nextDueAt` in the past with `nextDueOverdue: false` means the slot's
+ * anchor passed AFTER the block was built — render the plain day
+ * summary, never an overdue state, until a fresh block arrives.
+ */
+import type { PrismaClient } from "@/generated/prisma/client";
+import { projectTodayIntakesAndRecompute } from "@/lib/medications/scheduling/project-today-intakes";
+import {
+ computeDisplayDue,
+ OVERDUE_LOOKBACK_MS,
+ toResolvedSlotMark,
+ type ResolvedSlotMark,
+} from "@/lib/medications/scheduling/next-due";
+import { getUserTodayBounds } from "@/lib/tz/local-day";
+
+export interface MedsTodayBlock {
+ /** Active medications (paused courses excluded). */
+ activeCount: number;
+ /** Intake-event rows scheduled in the user's local today (all states). */
+ scheduledToday: number;
+ /** Rows with `takenAt` set and not skipped. */
+ takenToday: number;
+ /** Rows the user deliberately skipped. */
+ skippedToday: number;
+ /**
+ * Earliest display-due instant across active medications (ISO8601),
+ * or null when nothing is due (no schedules, course ended, all PRN).
+ * May lie outside today — the consumer gates on the local day.
+ */
+ nextDueAt: string | null;
+ /**
+ * True when `nextDueAt` is an OPEN overdue slot (anchor passed, still
+ * inside its catch-up band, unresolved). A cached `nextDueAt` in the
+ * past with `nextDueOverdue: false` must render as the plain summary,
+ * never as overdue — see the module doc.
+ */
+ nextDueOverdue: boolean;
+ /** Name of the medication carrying `nextDueAt`; null when none due. */
+ nextDueMedicationName: string | null;
+}
+
+export async function buildMedsTodayBlock(
+ prisma: PrismaClient,
+ userId: string,
+ userTz: string,
+ now: Date,
+): Promise {
+ const { start: todayStart, end: todayEnd } = getUserTodayBounds(now, userTz);
+ // The projector + tally read use an exclusive upper bound (`lt`),
+ // matching the summary route's window convention.
+ const todayEndExclusive = new Date(todayStart.getTime() + 24 * 60 * 60 * 1000);
+
+ // Projection FIRST so the tally read below sees the freshly minted
+ // pending rows. Idempotent — `skipDuplicates` + the
+ // `(userId, medicationId, scheduledFor, source)` unique index make a
+ // concurrent intake-route hit safe.
+ await projectTodayIntakesAndRecompute({
+ userId,
+ userTz,
+ todayStart,
+ todayEnd: todayEndExclusive,
+ });
+
+ // Resolved-slot window — same horizon the medications list route uses:
+ // back as far as the widest band tail (so a long-resolved past slot
+ // cannot resurface as overdue), forward two days for the lookahead.
+ const resolvedWindowStart = new Date(
+ todayStart.getTime() - OVERDUE_LOOKBACK_MS,
+ );
+ const resolvedWindowEnd = new Date(
+ todayEnd.getTime() + 2 * 24 * 60 * 60 * 1000,
+ );
+
+ const [medications, todayEvents, latestIntakes, resolvedEvents, eraFloors] =
+ await Promise.all([
+ prisma.medication.findMany({
+ where: { userId, active: true },
+ include: { schedules: true },
+ orderBy: { createdAt: "desc" },
+ }),
+ prisma.medicationIntakeEvent.findMany({
+ where: {
+ userId,
+ deletedAt: null,
+ scheduledFor: { gte: todayStart, lt: todayEndExclusive },
+ },
+ select: { takenAt: true, skipped: true },
+ }),
+ prisma.medicationIntakeEvent.groupBy({
+ by: ["medicationId"],
+ where: {
+ userId,
+ deletedAt: null,
+ skipped: false,
+ takenAt: { not: null },
+ },
+ _max: { takenAt: true },
+ }),
+ prisma.medicationIntakeEvent.findMany({
+ where: {
+ userId,
+ deletedAt: null,
+ scheduledFor: { gte: resolvedWindowStart, lte: resolvedWindowEnd },
+ OR: [
+ { takenAt: { not: null } },
+ { skipped: true },
+ { autoMissed: true },
+ ],
+ },
+ // v1.16.9 — `takenAt` rides along so an ad-hoc row (`scheduledFor
+ // === takenAt`) cannot ±6h-resolve a different slot.
+ select: { medicationId: true, scheduledFor: true, takenAt: true },
+ }),
+ // Current-era floor per medication: the newest revision's
+ // `validUntil` is where the LIVE schedule rows became valid; the
+ // open-overdue search must not reach past it into a previous
+ // era's cadence.
+ prisma.medicationScheduleRevision.groupBy({
+ by: ["medicationId"],
+ where: { medication: { userId }, supersededByRevisionId: null },
+ _max: { validUntil: true },
+ }),
+ ]);
+
+ const takenToday = todayEvents.filter(
+ (e) => e.takenAt !== null && !e.skipped,
+ ).length;
+ const skippedToday = todayEvents.filter((e) => e.skipped).length;
+
+ const lastTakenAtByMedId = new Map(
+ latestIntakes.map((entry) => [entry.medicationId, entry._max.takenAt]),
+ );
+ const resolvedSlotsByMedId = new Map();
+ for (const e of resolvedEvents) {
+ const mark = toResolvedSlotMark(e);
+ const list = resolvedSlotsByMedId.get(e.medicationId);
+ if (list) list.push(mark);
+ else resolvedSlotsByMedId.set(e.medicationId, [mark]);
+ }
+ const eraStartByMedId = new Map();
+ for (const f of eraFloors) {
+ if (f._max.validUntil) eraStartByMedId.set(f.medicationId, f._max.validUntil);
+ }
+
+ // Earliest display-due across active medications. An open overdue
+ // slot's anchor is in the past, so the minimum naturally prefers it
+ // over any future slot.
+ let nextDueAt: Date | null = null;
+ let nextDueOverdue = false;
+ let nextDueMedicationName: string | null = null;
+ for (const m of medications) {
+ const display = computeDisplayDue({
+ medication: {
+ id: m.id,
+ startsOn: m.startsOn,
+ endsOn: m.endsOn,
+ oneShot: m.oneShot,
+ createdAt: m.createdAt,
+ },
+ schedules: m.schedules,
+ now,
+ userTz,
+ lastIntakeAt: lastTakenAtByMedId.get(m.id) ?? null,
+ resolvedSlots: resolvedSlotsByMedId.get(m.id) ?? [],
+ eraStart: eraStartByMedId.get(m.id) ?? null,
+ });
+ if (!display) continue;
+ if (nextDueAt === null || display.at.getTime() < nextDueAt.getTime()) {
+ nextDueAt = display.at;
+ nextDueOverdue = display.overdue;
+ nextDueMedicationName = m.name;
+ }
+ }
+
+ return {
+ activeCount: medications.length,
+ scheduledToday: todayEvents.length,
+ takenToday,
+ skippedToday,
+ nextDueAt: nextDueAt ? nextDueAt.toISOString() : null,
+ nextDueOverdue,
+ nextDueMedicationName,
+ };
+}
diff --git a/src/lib/dashboard/snapshot.ts b/src/lib/dashboard/snapshot.ts
index 945ee4f14..bb633d37d 100644
--- a/src/lib/dashboard/snapshot.ts
+++ b/src/lib/dashboard/snapshot.ts
@@ -66,6 +66,12 @@ import { dailyBriefingSchema, type DailyBriefing } from "@/lib/ai/schema";
import { getAssistantFlags } from "@/lib/feature-flags";
import { hasAnyConfiguredProvider } from "@/lib/ai/provider";
import { DEFAULT_TIMEZONE } from "@/lib/tz/resolver";
+import {
+ buildMedsTodayBlock,
+ type MedsTodayBlock,
+} from "@/lib/dashboard/meds-today";
+import { computeUserHealthScoreFastPath } from "@/lib/analytics/health-score-fast-path";
+import type { HealthScoreBand } from "@/lib/analytics/health-score";
/** Briefing freshness window — mirrors the 24 h TTL on the advisor cache. */
const BRIEFING_TTL_MS = 24 * 60 * 60 * 1000;
@@ -213,6 +219,18 @@ export interface DashboardLayoutCatalogueEntry {
order: number;
}
+/**
+ * Health-score summary for the hero — score + band + week-over-week
+ * delta ONLY. The per-pillar component breakdown is deliberately NOT
+ * serialised here; the analytics route remains the one surface that
+ * exposes components.
+ */
+export interface DashboardSnapshotHealthScore {
+ score: number;
+ band: HealthScoreBand;
+ delta: number | null;
+}
+
export interface DashboardSnapshot {
user: DashboardSnapshotUser;
layout: DashboardLayout;
@@ -241,6 +259,24 @@ export interface DashboardSnapshot {
};
/** Thick phase — null on a rollup-coverage miss. */
extras: DashboardSnapshotExtras | null;
+ /**
+ * Fast phase — today's medication block (projection-backed tally +
+ * earliest next-due across active medications).
+ *
+ * Caching contract: the snapshot is served read-through a cache, so
+ * `medsToday.nextDueAt` can sit in the past with
+ * `medsToday.nextDueOverdue: false` when the slot's anchor passed
+ * AFTER the snapshot was built. Consumers MUST render that state as
+ * the plain day summary — never as overdue — until a fresh snapshot
+ * carries `nextDueOverdue: true` from the band model itself.
+ */
+ medsToday: MedsTodayBlock;
+ /**
+ * Warm-phase health score (score + band + delta only — no
+ * components). `null` on a rollup-coverage miss (the score rides the
+ * thick phase alongside `extras`) and when no pillar is computable.
+ */
+ healthScore: DashboardSnapshotHealthScore | null;
briefing: DailyBriefing | null;
briefingState: BriefingState;
briefingUpdatedAt: string | null;
@@ -377,29 +413,40 @@ async function buildMoodBlock(
}
/**
- * Thick slice — BD-Zielbereich + per-context glucose. Only called by
- * the builder when the rollup tier is warm (`isFullyCovered`); the BP
- * fast-path then stays on the sub-second rollup branch and never drops
- * into the multi-second live fallback that would make the whole strip
- * wait. On a coverage miss the builder skips this entirely and emits
- * `extras: null` (per-tile shimmer until the boot backfill converges).
+ * Thick slice — BD-Zielbereich + per-context glucose + health score.
+ * Only called by the builder when the rollup tier is warm
+ * (`isFullyCovered`); the BP fast-path then stays on the sub-second
+ * rollup branch and never drops into the multi-second live fallback
+ * that would make the whole strip wait. On a coverage miss the builder
+ * skips this entirely and emits `extras: null` + `healthScore: null`
+ * (per-tile shimmer until the boot backfill converges).
+ *
+ * The health score rides this warm phase because it reuses the BP
+ * windows already computed here (`gradedScore` + `last30Days.pct`) and
+ * the same coverage map, so the score's weight pillar also stays on
+ * the rollup branch.
*/
async function buildExtras(
prisma: PrismaClient,
user: SnapshotUserInput,
userTz: string,
coverage: RollupCoverageMap,
-): Promise {
+ now: Date,
+ time: (label: string, fn: () => Promise) => Promise,
+): Promise<{
+ extras: DashboardSnapshotExtras;
+ healthScore: DashboardSnapshotHealthScore | null;
+}> {
let bpInTargetPct: number | null = null;
let bpInTargetPct7d: number | null = null;
let bpInTargetPct30d: number | null = null;
let bpInTargetPctAllTime: number | null = null;
let bpInTargetPctPriorMonth: number | null = null;
let bpInTargetPctPriorYear: number | null = null;
+ let bpGradedScore: number | null = null;
const bpTargets = getBpTargets(user.dateOfBirth);
if (bpTargets) {
- const now = new Date();
const windows = await computeBpInTargetFastPath({
userId: user.id,
targets: bpTargets,
@@ -413,8 +460,30 @@ async function buildExtras(
bpInTargetPctAllTime = windows.allTime?.pct ?? null;
bpInTargetPctPriorMonth = windows.priorMonth?.pct ?? null;
bpInTargetPctPriorYear = windows.priorYear?.pct ?? null;
+ bpGradedScore = windows.gradedScore ?? null;
}
+ // Health score — reuses the BP windows captured above plus the
+ // already-probed coverage map (no second probe). Score + band +
+ // delta only; the component breakdown stays off this wire.
+ const scoreResult = await time("healthScore", () =>
+ computeUserHealthScoreFastPath({
+ userId: user.id,
+ bpInTargetPct,
+ bpGradedScore,
+ heightCm: user.heightCm,
+ now,
+ coverage,
+ }),
+ );
+ const healthScore: DashboardSnapshotHealthScore | null = scoreResult
+ ? {
+ score: scoreResult.score,
+ band: scoreResult.band,
+ delta: scoreResult.delta,
+ }
+ : null;
+
const glucoseSince = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
const glucoseRows = await prisma.measurement.findMany({
where: {
@@ -440,13 +509,16 @@ async function buildExtras(
}
return {
- bpInTargetPct,
- bpInTargetPct7d,
- bpInTargetPct30d,
- bpInTargetPctAllTime,
- bpInTargetPctPriorMonth,
- bpInTargetPctPriorYear,
- glucoseByContext,
+ extras: {
+ bpInTargetPct,
+ bpInTargetPct7d,
+ bpInTargetPct30d,
+ bpInTargetPctAllTime,
+ bpInTargetPctPriorMonth,
+ bpInTargetPctPriorYear,
+ glucoseByContext,
+ },
+ healthScore,
};
}
@@ -646,15 +718,19 @@ export async function buildDashboardSnapshot(
const coverage = await time("coverage", () => probeRollupCoverage(user.id));
const warm = isFullyCovered(coverage);
- const [slim, mood, extras, flags] = await Promise.all([
+ const [slim, mood, extrasResult, flags, medsToday] = await Promise.all([
// A5 — reuse the coverage map already probed above so the slice
// doesn't re-run the identical `probeRollupCoverage` query.
time("summaries", () => computeSummariesSlice(user.id, coverage)),
time("mood", () => buildMoodBlock(prisma, user.id)),
warm
- ? time("extras", () => buildExtras(prisma, user, userTz, coverage))
+ ? time("extras", () =>
+ buildExtras(prisma, user, userTz, coverage, now, time),
+ )
: Promise.resolve(null),
time("flags", () => getAssistantFlags()),
+ // Fast phase — projection-backed today tally + earliest next-due.
+ time("medsToday", () => buildMedsTodayBlock(prisma, user.id, userTz, now)),
]);
const layout = resolveDashboardLayout(user.dashboardWidgetsJson);
@@ -689,7 +765,9 @@ export async function buildDashboardSnapshot(
entries: mood.entries,
},
},
- extras,
+ extras: extrasResult?.extras ?? null,
+ medsToday,
+ healthScore: extrasResult?.healthScore ?? null,
briefing: briefing.briefing,
briefingState: briefing.briefingState,
briefingUpdatedAt: briefing.briefingUpdatedAt,
diff --git a/src/lib/dashboard/verdict.ts b/src/lib/dashboard/verdict.ts
new file mode 100644
index 000000000..59c62e330
--- /dev/null
+++ b/src/lib/dashboard/verdict.ts
@@ -0,0 +1,286 @@
+/**
+ * Dashboard hero — daily-verdict resolver.
+ *
+ * Pure function over an already-built `DashboardSnapshot`: no DB, no
+ * network, no clock read (`now` is injected so the resolver is
+ * deterministic under test and a cached snapshot can be re-evaluated
+ * against the current instant).
+ *
+ * Nine rungs, first hit wins. The ordering is a severity ladder:
+ * the fixed-floor BP emergency first (a fresh crisis-level reading
+ * outranks an overdue dose), then the actionable medication states,
+ * then trend nudges, then the briefing teaser, then the all-quiet
+ * fallback. Threshold constants are imported from the client-safe
+ * coach-nudge-thresholds leaf where one exists so the hero and the
+ * nudge cron can never disagree on what "drift" or "deficit" means —
+ * and so this module never pulls the cron's server graph into a
+ * client bundle (this resolver runs inside `"use client"` code).
+ *
+ * Freshness is re-derived from the snapshot's ISO timestamps against
+ * the injected `now` (not the snapshot's own `daysAgo` fields) so a
+ * snapshot served from cache ages honestly.
+ *
+ * Defensive contract (cache staleness): a `medsToday.nextDueAt` in the
+ * past with `nextDueOverdue: false` means the slot's anchor passed
+ * after the snapshot was built. Rung 2 keys ONLY on the server-computed
+ * `nextDueOverdue` flag and rung 3 requires `nextDueAt >= now`, so that
+ * state falls through to the plain summary — never renders as overdue.
+ */
+import {
+ COACH_NUDGE_WEIGHT_DRIFT_KG,
+ COACH_NUDGE_SLEEP_DEFICIT_MARGIN_H,
+} from "@/lib/jobs/coach-nudge-thresholds";
+import { buildWeightRangeFromHeight } from "@/lib/analytics/value-bands";
+import type { DashboardSnapshot } from "@/lib/dashboard/snapshot";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Fixed clinical floors for the BP-critical rung (ESC/ESH grade-3 /
+ * hypertensive-crisis territory). Deliberately NOT the user's
+ * personal targets — a user-relaxed threshold must never silence a
+ * 180/110 reading on the hero.
+ */
+const BP_CRITICAL_SYS_FLOOR = 180;
+const BP_CRITICAL_DIA_FLOOR = 110;
+/** A critical reading older than this many days is history, not an alert. */
+const BP_CRITICAL_MAX_DAYS_AGO = 1;
+
+/** Rung 3 — surface a dose at most this far before its anchor. */
+const DOSE_UPCOMING_WINDOW_MS = 2 * 60 * 60 * 1000;
+
+/** Rung 5 — nightly floor (hours) the short-nights rung measures against. */
+const SHORT_NIGHTS_FLOOR_H = 7;
+/** Rung 5 — minimum readings in the summary window before the rung fires. */
+const SHORT_NIGHTS_MIN_COUNT = 5;
+
+/** Rung 6 — every logged-ever core vital silent for at least this long. */
+const SILENCE_MIN_DAYS = 7;
+/** Rung 6 — the core vitals the silence rung watches. */
+const SILENCE_TYPES = [
+ "WEIGHT",
+ "BLOOD_PRESSURE_SYS",
+ "BLOOD_GLUCOSE",
+] as const;
+
+/** Rung 7 — week-over-week score drop (points) that fires. */
+const SCORE_DROP_MIN_POINTS = 10;
+
+export type DashboardVerdictVariant =
+ | "doseOverdue"
+ | "bpCritical"
+ | "doseUpcoming"
+ | "weightDrift"
+ | "shortNights"
+ | "silence"
+ | "scoreDrop"
+ | "briefing"
+ | "allQuiet";
+
+export type DashboardVerdictCta =
+ | { kind: "quickEntry"; target: "medicationIntake" | "measurement" }
+ | { kind: "link"; href: string };
+
+export interface DashboardVerdict {
+ variant: DashboardVerdictVariant;
+ /**
+ * Interpolation values for the variant's i18n message. `briefing`
+ * carries the model-authored headline VERBATIM under `headline`;
+ * renderers must emit it as plain text children (no HTML, no
+ * markdown) per the repo-wide no-markdown-renderer rule.
+ */
+ values: Record;
+ cta: DashboardVerdictCta | null;
+}
+
+/** YYYY-MM-DD key of `d`'s calendar day in `tz`. */
+function dayKeyInTz(d: Date, tz: string): string {
+ return new Intl.DateTimeFormat("en-CA", {
+ timeZone: tz,
+ year: "numeric",
+ month: "2-digit",
+ day: "2-digit",
+ }).format(d);
+}
+
+/** HH:mm wall-clock of `d` in `tz`. */
+function hmInTz(d: Date, tz: string): string {
+ const parts = new Intl.DateTimeFormat("en-GB", {
+ timeZone: tz,
+ hour: "2-digit",
+ minute: "2-digit",
+ hour12: false,
+ }).format(d);
+ // Some ICU builds emit "24:xx" for midnight under hour12: false.
+ return parts.startsWith("24") ? `00${parts.slice(2)}` : parts;
+}
+
+/** Whole days between an ISO instant and `now` (floor; negative-safe). */
+function daysSince(iso: string, now: Date): number {
+ return Math.floor((now.getTime() - Date.parse(iso)) / DAY_MS);
+}
+
+export function resolveDashboardVerdict(
+ snapshot: DashboardSnapshot,
+ now: Date,
+): DashboardVerdict {
+ const meds = snapshot.medsToday;
+ const tz = snapshot.user.timezone;
+ const summaries = snapshot.tiles.summaries;
+ const lastSeen = snapshot.tiles.lastSeenByType;
+
+ // ── 1 · bpCritical ─────────────────────────────────────────────────
+ // Fixed floors (sys ≥ 180 OR dia ≥ 110), never user thresholds, and
+ // only while the reading is fresh (≤ 1 day, re-derived against the
+ // injected `now`). Sits ABOVE the overdue dose: a fresh crisis-level
+ // reading is the one item that must not hide behind a routine
+ // medication prompt.
+ const sysLatest = summaries.BLOOD_PRESSURE_SYS?.latest ?? null;
+ const diaLatest = summaries.BLOOD_PRESSURE_DIA?.latest ?? null;
+ const sysSeen = lastSeen.BLOOD_PRESSURE_SYS;
+ const bpCriticalValue =
+ (sysLatest !== null && sysLatest >= BP_CRITICAL_SYS_FLOOR) ||
+ (diaLatest !== null && diaLatest >= BP_CRITICAL_DIA_FLOOR);
+ if (
+ bpCriticalValue &&
+ sysSeen &&
+ daysSince(sysSeen.lastSeenAt, now) <= BP_CRITICAL_MAX_DAYS_AGO
+ ) {
+ return {
+ variant: "bpCritical",
+ values: { sys: sysLatest ?? 0, dia: diaLatest ?? 0 },
+ cta: { kind: "link", href: "/insights/blood-pressure" },
+ };
+ }
+
+ // ── 2 · doseOverdue ────────────────────────────────────────────────
+ // Keys ONLY on the server-computed band-model flag. A stale cached
+ // `nextDueAt` in the past with `nextDueOverdue: false` falls through
+ // (defensive contract — see module doc).
+ if (meds.nextDueOverdue === true) {
+ return {
+ variant: "doseOverdue",
+ values: { name: meds.nextDueMedicationName ?? "" },
+ cta: { kind: "quickEntry", target: "medicationIntake" },
+ };
+ }
+
+ // ── 3 · doseUpcoming ───────────────────────────────────────────────
+ // Unresolved doses remain today AND the next anchor sits within the
+ // next two hours on the user's local calendar day.
+ const unresolvedToday =
+ meds.scheduledToday > meds.takenToday + meds.skippedToday;
+ if (unresolvedToday && meds.nextDueAt !== null) {
+ const dueMs = Date.parse(meds.nextDueAt);
+ const untilDue = dueMs - now.getTime();
+ if (
+ untilDue >= 0 &&
+ untilDue <= DOSE_UPCOMING_WINDOW_MS &&
+ dayKeyInTz(new Date(dueMs), tz) === dayKeyInTz(now, tz)
+ ) {
+ return {
+ variant: "doseUpcoming",
+ values: {
+ time: hmInTz(new Date(dueMs), tz),
+ name: meds.nextDueMedicationName ?? "",
+ },
+ cta: { kind: "quickEntry", target: "medicationIntake" },
+ };
+ }
+ }
+
+ // ── 4 · weightDrift ────────────────────────────────────────────────
+ // Distance-to-green-range drift: the 7-day mean sits further from
+ // the BMI-derived green band than the 30-day mean by at least the
+ // coach-nudge drift threshold. No stored height → no range → skip.
+ const weight = summaries.WEIGHT;
+ if (
+ snapshot.user.heightCm !== null &&
+ weight &&
+ weight.avg7 !== null &&
+ weight.avg30 !== null
+ ) {
+ const range = buildWeightRangeFromHeight(snapshot.user.heightCm);
+ const dist = (x: number): number =>
+ Math.max(0, range.greenMin - x, x - range.greenMax);
+ if (dist(weight.avg7) - dist(weight.avg30) >= COACH_NUDGE_WEIGHT_DRIFT_KG) {
+ return {
+ variant: "weightDrift",
+ values: {},
+ cta: { kind: "link", href: "/insights/weight" },
+ };
+ }
+ }
+
+ // ── 5 · shortNights ────────────────────────────────────────────────
+ // 7-day mean sleep (stored in minutes) clearly under the floor, with
+ // enough readings that a sparse week stays silent. The clear-margin
+ // is the same constant the coach-nudge sleep trigger uses.
+ const sleep = summaries.SLEEP_DURATION;
+ if (sleep && sleep.avg7 !== null && sleep.count >= SHORT_NIGHTS_MIN_COUNT) {
+ const floorMinutes =
+ (SHORT_NIGHTS_FLOOR_H - COACH_NUDGE_SLEEP_DEFICIT_MARGIN_H) * 60;
+ if (sleep.avg7 < floorMinutes) {
+ return {
+ variant: "shortNights",
+ values: { hours: Math.round((sleep.avg7 / 60) * 10) / 10 },
+ cta: { kind: "link", href: "/insights/sleep" },
+ };
+ }
+ }
+
+ // ── 6 · silence ────────────────────────────────────────────────────
+ // EVERY logged-ever core vital has been silent for ≥ 7 days (min over
+ // the per-type ages). Types the user never logged don't count — a
+ // BP-only account is judged on BP alone.
+ let minDaysAgo: number | null = null;
+ for (const type of SILENCE_TYPES) {
+ const seen = lastSeen[type];
+ if (!seen) continue;
+ const days = daysSince(seen.lastSeenAt, now);
+ if (minDaysAgo === null || days < minDaysAgo) minDaysAgo = days;
+ }
+ if (minDaysAgo !== null && minDaysAgo >= SILENCE_MIN_DAYS) {
+ return {
+ variant: "silence",
+ values: { days: minDaysAgo },
+ cta: { kind: "quickEntry", target: "measurement" },
+ };
+ }
+
+ // ── 7 · scoreDrop ──────────────────────────────────────────────────
+ const score = snapshot.healthScore;
+ if (
+ score !== null &&
+ score.delta !== null &&
+ score.delta <= -SCORE_DROP_MIN_POINTS
+ ) {
+ return {
+ variant: "scoreDrop",
+ values: { points: Math.round(Math.abs(score.delta)) },
+ cta: { kind: "link", href: "/insights" },
+ };
+ }
+
+ // ── 8 · briefing ───────────────────────────────────────────────────
+ // Fresh briefing only (`ready` + not stale) with at least one key
+ // finding. Prefer a "watch"-tone finding; the headline rides verbatim
+ // as plain text — see the `values` doc.
+ if (
+ snapshot.briefingState === "ready" &&
+ !snapshot.briefingStale &&
+ snapshot.briefing !== null &&
+ snapshot.briefing.keyFindings.length > 0
+ ) {
+ const findings = snapshot.briefing.keyFindings;
+ const picked = findings.find((f) => f.tone === "watch") ?? findings[0];
+ return {
+ variant: "briefing",
+ values: { headline: picked.headline },
+ cta: { kind: "link", href: "/insights" },
+ };
+ }
+
+ // ── 9 · allQuiet ───────────────────────────────────────────────────
+ return { variant: "allQuiet", values: {}, cta: null };
+}
diff --git a/src/lib/insights/__tests__/prompt-soft-delete-filter.test.ts b/src/lib/insights/__tests__/prompt-soft-delete-filter.test.ts
index 8e2778214..f37ced16d 100644
--- a/src/lib/insights/__tests__/prompt-soft-delete-filter.test.ts
+++ b/src/lib/insights/__tests__/prompt-soft-delete-filter.test.ts
@@ -40,9 +40,12 @@ describe("prompt reads exclude tombstoned rows", () => {
});
it("the Coach snapshot filters its intake read", () => {
+ // v1.16.9 — the compliance timeline reads intake events through the
+ // medication relation (`intakeEvents`) so the ledger can be rebuilt
+ // per medication; the tombstone filter must ride on that nested read.
const src = read("../../ai/coach/snapshot.ts");
const intakeRead = src.match(
- /medicationIntakeEvent\.findMany\(\{[\s\S]{0,200}?where:\s*\{[^}]*\}/,
+ /intakeEvents:\s*\{[\s\S]{0,300}?where:\s*\{[^}]*\}/,
);
expect(intakeRead).not.toBeNull();
expect(intakeRead![0]).toContain("deletedAt: null");
diff --git a/src/lib/jobs/coach-nudge-thresholds.ts b/src/lib/jobs/coach-nudge-thresholds.ts
new file mode 100644
index 000000000..8cf107bb9
--- /dev/null
+++ b/src/lib/jobs/coach-nudge-thresholds.ts
@@ -0,0 +1,19 @@
+/**
+ * Coach-nudge trend thresholds shared with client-reachable code.
+ *
+ * Kept in a leaf module — free of any server-only import — because the
+ * dashboard hero's verdict resolver (`@/lib/dashboard/verdict`) reads
+ * these to stay numerically identical to the nudge cron, and that
+ * resolver runs inside a `"use client"` component. Importing them from
+ * `@/lib/jobs/coach-nudge` would drag the prisma/dispatcher server
+ * graph into the browser bundle (the same regression class the
+ * dose-window defaults hit — see
+ * `src/lib/medications/scheduling/dose-window-defaults.ts`).
+ * `@/lib/jobs/coach-nudge` re-exports both so server-side imports keep
+ * their path.
+ */
+
+/** Weight trigger: minimum kg the weekly mean must drift AWAY from the range. */
+export const COACH_NUDGE_WEIGHT_DRIFT_KG = 0.5;
+/** Sleep trigger: a night must undershoot the floor by this margin (h). */
+export const COACH_NUDGE_SLEEP_DEFICIT_MARGIN_H = 0.5;
diff --git a/src/lib/jobs/coach-nudge.ts b/src/lib/jobs/coach-nudge.ts
index 5b4c4281a..d931e1733 100644
--- a/src/lib/jobs/coach-nudge.ts
+++ b/src/lib/jobs/coach-nudge.ts
@@ -77,6 +77,18 @@ import { getServerTranslator } from "@/lib/i18n/server-translator";
import type { Locale } from "@/lib/i18n/config";
import { defaultLocale, locales } from "@/lib/i18n/config";
import { getEvent } from "@/lib/logging/context";
+// Trend thresholds shared with the dashboard hero's verdict resolver
+// live in a client-safe leaf module; re-exported below so server-side
+// imports keep their path.
+import {
+ COACH_NUDGE_WEIGHT_DRIFT_KG,
+ COACH_NUDGE_SLEEP_DEFICIT_MARGIN_H,
+} from "@/lib/jobs/coach-nudge-thresholds";
+
+export {
+ COACH_NUDGE_WEIGHT_DRIFT_KG,
+ COACH_NUDGE_SLEEP_DEFICIT_MARGIN_H,
+} from "@/lib/jobs/coach-nudge-thresholds";
const MS_PER_DAY = 24 * 60 * 60 * 1000;
@@ -109,14 +121,10 @@ export const COACH_NUDGE_SELF_CONTEXT_STALE_DAYS = 60;
export const COACH_NUDGE_COACH_ACTIVE_DAYS = 14;
/** Weight trigger: minimum readings per weekly window. */
export const COACH_NUDGE_WEIGHT_MIN_READINGS = 3;
-/** Weight trigger: minimum kg the weekly mean must drift AWAY from the range. */
-export const COACH_NUDGE_WEIGHT_DRIFT_KG = 0.5;
/** Sleep trigger: minimum recorded nights in the 7-day window. */
export const COACH_NUDGE_SLEEP_MIN_NIGHTS = 5;
/** Sleep trigger: nights under the floor required to fire. */
export const COACH_NUDGE_SLEEP_DEFICIT_NIGHTS = 4;
-/** Sleep trigger: a night must undershoot the floor by this margin (h). */
-export const COACH_NUDGE_SLEEP_DEFICIT_MARGIN_H = 0.5;
/** Gap trigger: distinct active days required in the prior 3 weeks. */
export const COACH_NUDGE_GAP_MIN_ACTIVE_DAYS = 10;
/** Gap trigger: length of the silent window that fires (days). */
diff --git a/src/lib/medications/__tests__/intake-slot-dedup-converge.test.ts b/src/lib/medications/__tests__/intake-slot-dedup-converge.test.ts
new file mode 100644
index 000000000..e9b0ba44b
--- /dev/null
+++ b/src/lib/medications/__tests__/intake-slot-dedup-converge.test.ts
@@ -0,0 +1,261 @@
+/**
+ * v1.16.9 — ad-hoc→pending band convergence in the nightly dedup.
+ *
+ * The production damage this heals: the external-API and Telegram write
+ * paths historically bare-created `scheduledFor = takenAt`, leaving the
+ * worker-minted pending REMINDER row open. The legacy snap pass only
+ * reaches a ± half-window tolerance and the discovery query only matched
+ * 2-minute drift, so an 08:42 API take beside its pending 09:00 row
+ * never collapsed — the ledger showed an ad-hoc take PLUS a missed slot
+ * for one real dose.
+ *
+ * Covered here:
+ * 1. The 08:42 / 09:00 pair heals: the pending row tombstones, the
+ * take normalises onto the canonical anchor.
+ * 2. A take outside the legacy snap tolerance but inside the band's
+ * late tail still heals (the case the snap pass can never reach).
+ * 3. An ambiguous double-slot (two live rows on the anchor) is left
+ * alone by the convergence pass.
+ * 4. A WEB ad-hoc row (deliberate user shape) is never converged.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/db", () => ({
+ prisma: {
+ user: { findUnique: vi.fn() },
+ medication: { findMany: vi.fn() },
+ medicationIntakeEvent: {
+ findFirst: vi.fn(),
+ findMany: vi.fn(),
+ updateMany: vi.fn(),
+ update: vi.fn(),
+ },
+ },
+}));
+
+vi.mock("@/lib/jobs/boss-instance", () => ({ getGlobalBoss: vi.fn() }));
+vi.mock("@/lib/logging/context", () => ({ annotate: vi.fn() }));
+vi.mock("@/lib/rollups/medication-compliance-rollups", () => ({
+ recomputeMedicationComplianceForEvent: vi.fn().mockResolvedValue(undefined),
+}));
+
+import { dedupeUserIntakeSlots } from "../intake-slot-dedup";
+import { prisma } from "@/lib/db";
+
+const TZ = "Europe/Berlin";
+
+// Daily 09:00 Berlin med. 09:00 CEST on 2026-06-10 = 07:00:00Z.
+const SLOT_0900 = new Date("2026-06-10T07:00:00.000Z");
+const TAKEN_0842 = new Date("2026-06-10T06:42:00.000Z");
+// 12:30 Berlin — outside the ±2h legacy snap tolerance of the 09:00
+// anchor, but inside the band's late tail (on-time end 10:00 + 180 min).
+const TAKEN_1230 = new Date("2026-06-10T10:30:00.000Z");
+
+const SCHEDULE = {
+ id: "s1",
+ windowStart: "09:00",
+ windowEnd: "09:00",
+ daysOfWeek: null,
+ timesOfDay: ["09:00"],
+ reminderGraceMinutes: null,
+ rrule: "FREQ=DAILY",
+ rollingIntervalDays: null,
+ scheduleType: "SCHEDULED",
+ cyclicOnWeeks: null,
+ cyclicOffWeeks: null,
+ doseWindows: null,
+};
+
+const MED = {
+ id: "med-1",
+ userId: "u1",
+ startsOn: null,
+ endsOn: null,
+ oneShot: false,
+ createdAt: new Date("2026-01-01T00:00:00Z"),
+ schedules: [SCHEDULE],
+ scheduleRevisions: [],
+};
+
+function pendingRow(over: Record = {}) {
+ return {
+ id: "r-pending",
+ medicationId: "med-1",
+ scheduledFor: SLOT_0900,
+ takenAt: null,
+ skipped: false,
+ syncVersion: 0,
+ createdAt: new Date("2026-06-10T05:00:00Z"),
+ attributionSource: "AUTO",
+ source: "REMINDER",
+ ...over,
+ };
+}
+
+function adhocRow(at: Date, over: Record = {}) {
+ return {
+ id: "r-adhoc",
+ medicationId: "med-1",
+ scheduledFor: at,
+ takenAt: at,
+ skipped: false,
+ syncVersion: 1,
+ createdAt: at,
+ attributionSource: "AUTO",
+ source: "API",
+ ...over,
+ };
+}
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(prisma.user.findUnique).mockResolvedValue({
+ timezone: TZ,
+ } as never);
+ vi.mocked(prisma.medication.findMany).mockResolvedValue([MED] as never);
+ vi.mocked(prisma.medicationIntakeEvent.findFirst).mockResolvedValue(
+ null as never,
+ );
+ vi.mocked(prisma.medicationIntakeEvent.updateMany).mockResolvedValue({
+ count: 1,
+ } as never);
+ vi.mocked(prisma.medicationIntakeEvent.update).mockResolvedValue({} as never);
+});
+
+describe("dedupeUserIntakeSlots — ad-hoc→pending convergence (v1.16.9)", () => {
+ it("heals the 08:42 API take / pending 09:00 REMINDER pair", async () => {
+ vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue([
+ adhocRow(TAKEN_0842),
+ pendingRow(),
+ ] as never);
+
+ const summary = await dedupeUserIntakeSlots("u1");
+
+ // The pending row tombstones; the take is the dose of record.
+ expect(prisma.medicationIntakeEvent.updateMany).toHaveBeenCalledTimes(1);
+ const tombstone = vi.mocked(prisma.medicationIntakeEvent.updateMany).mock
+ .calls[0][0] as {
+ where: { id: string };
+ data: { deletedAt: Date };
+ };
+ expect(tombstone.where.id).toBe("r-pending");
+ expect(tombstone.data.deletedAt).toBeInstanceOf(Date);
+
+ // The take normalises onto the canonical 09:00 anchor.
+ expect(prisma.medicationIntakeEvent.update).toHaveBeenCalledTimes(1);
+ const normalise = vi.mocked(prisma.medicationIntakeEvent.update).mock
+ .calls[0][0] as {
+ where: { id: string };
+ data: { scheduledFor: Date };
+ };
+ expect(normalise.where.id).toBe("r-adhoc");
+ expect(normalise.data.scheduledFor.getTime()).toBe(SLOT_0900.getTime());
+
+ expect(summary.rowsSoftDeleted).toBe(1);
+ expect(summary.rowsNormalised).toBe(1);
+ expect(summary.slotsCollapsed).toBe(1);
+ expect(summary.daysRecomputed).toBeGreaterThanOrEqual(1);
+ });
+
+ it("heals an early take ahead of an explicit window that starts AT the dose time", async () => {
+ // Explicit 09:00–10:00 dose window: the on-time band starts AT the
+ // dose time, so an 08:42 take sits only inside the bounded early
+ // grace below `onTimeStart`. The convergence must accept it exactly
+ // like the write-path attribution does — otherwise the actioned
+ // ad-hoc row stays beside the unactioned 09:00 REMINDER row and the
+ // slot later auto-misses a dose the user took.
+ vi.mocked(prisma.medication.findMany).mockResolvedValue([
+ {
+ ...MED,
+ schedules: [
+ {
+ ...SCHEDULE,
+ windowStart: "09:00",
+ windowEnd: "10:00",
+ doseWindows: [{ timeOfDay: "09:00", start: "09:00", end: "10:00" }],
+ },
+ ],
+ },
+ ] as never);
+ vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue([
+ adhocRow(TAKEN_0842),
+ pendingRow(),
+ ] as never);
+
+ const summary = await dedupeUserIntakeSlots("u1");
+
+ const tombstone = vi.mocked(prisma.medicationIntakeEvent.updateMany).mock
+ .calls[0][0] as { where: { id: string } };
+ expect(tombstone.where.id).toBe("r-pending");
+ const normalise = vi.mocked(prisma.medicationIntakeEvent.update).mock
+ .calls[0][0] as { where: { id: string }; data: { scheduledFor: Date } };
+ expect(normalise.where.id).toBe("r-adhoc");
+ expect(normalise.data.scheduledFor.getTime()).toBe(SLOT_0900.getTime());
+ expect(summary.slotsCollapsed).toBe(1);
+ });
+
+ it("heals a take outside the legacy snap tolerance but inside the band's late tail", async () => {
+ vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue([
+ adhocRow(TAKEN_1230),
+ pendingRow(),
+ ] as never);
+
+ const summary = await dedupeUserIntakeSlots("u1");
+
+ expect(summary.rowsSoftDeleted).toBe(1);
+ expect(summary.rowsNormalised).toBe(1);
+ const tombstone = vi.mocked(prisma.medicationIntakeEvent.updateMany).mock
+ .calls[0][0] as { where: { id: string } };
+ expect(tombstone.where.id).toBe("r-pending");
+ const normalise = vi.mocked(prisma.medicationIntakeEvent.update).mock
+ .calls[0][0] as { where: { id: string }; data: { scheduledFor: Date } };
+ expect(normalise.where.id).toBe("r-adhoc");
+ expect(normalise.data.scheduledFor.getTime()).toBe(SLOT_0900.getTime());
+ });
+
+ it("leaves an ambiguous double-slot (two live rows on the anchor) alone", async () => {
+ // Two live rows already sit on the 09:00 anchor — converging the take
+ // would have to pick one blindly. The convergence pass declines; the
+ // take stays where it is. (The legacy exact-instant collapse of the
+ // two anchor rows is a separate, pre-existing pass.)
+ vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue([
+ adhocRow(TAKEN_1230),
+ pendingRow(),
+ pendingRow({ id: "r-pending-2", source: "API" }),
+ ] as never);
+
+ await dedupeUserIntakeSlots("u1");
+
+ // The ad-hoc take was never normalised onto the anchor.
+ const normaliseCalls = vi
+ .mocked(prisma.medicationIntakeEvent.update)
+ .mock.calls.map((c) => (c[0] as { where: { id: string } }).where.id);
+ expect(normaliseCalls).not.toContain("r-adhoc");
+ });
+
+ it("never converges a WEB ad-hoc row (deliberate user shape)", async () => {
+ vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue([
+ adhocRow(TAKEN_1230, { source: "WEB" }),
+ pendingRow(),
+ ] as never);
+
+ const summary = await dedupeUserIntakeSlots("u1");
+
+ expect(summary.rowsSoftDeleted).toBe(0);
+ expect(summary.rowsNormalised).toBe(0);
+ expect(prisma.medicationIntakeEvent.updateMany).not.toHaveBeenCalled();
+ expect(prisma.medicationIntakeEvent.update).not.toHaveBeenCalled();
+ });
+
+ it("never converges a USER_PIN released row", async () => {
+ vi.mocked(prisma.medicationIntakeEvent.findMany).mockResolvedValue([
+ adhocRow(TAKEN_1230, { attributionSource: "USER_PIN" }),
+ pendingRow(),
+ ] as never);
+
+ const summary = await dedupeUserIntakeSlots("u1");
+
+ expect(summary.rowsSoftDeleted).toBe(0);
+ expect(prisma.medicationIntakeEvent.updateMany).not.toHaveBeenCalled();
+ });
+});
diff --git a/src/lib/medications/__tests__/window-status.test.ts b/src/lib/medications/__tests__/window-status.test.ts
index 23dcb806f..ce6328f62 100644
--- a/src/lib/medications/__tests__/window-status.test.ts
+++ b/src/lib/medications/__tests__/window-status.test.ts
@@ -365,3 +365,95 @@ describe("reduceCurrentWindowStatus — display-due gate (v1.16.6)", () => {
expect(res.status).toBeNull();
});
});
+
+/**
+ * v1.16.9 — day-scale early-take downgrade. A weekly injectable taken two
+ * days before its slot day is already on board; on the slot day the
+ * in-window pill must carry taken-early context instead of prompting a
+ * full take (a "take now" there is a double-dose prompt).
+ */
+describe("reduceCurrentWindowStatus — day-scale taken-early context", () => {
+ // Weekly Wednesday 09:00 (2026-06-10 is a Wednesday). daysOfWeek "3" =
+ // Wednesday in the legacy CSV encoding.
+ const weeklyWedSchedule = {
+ windowStart: "09:00",
+ windowEnd: "09:00",
+ daysOfWeek: "3",
+ timesOfDay: ["09:00"],
+ };
+ // Monday 2026-06-08, 08:00 Berlin (CEST) — two days before the slot day.
+ const MONDAY_TAKE = "2026-06-08T06:00:00.000Z";
+
+ it("flags takenEarly on the slot day after a Monday take (Mon-take/Wed-slot)", () => {
+ const res = reduceCurrentWindowStatus({
+ ...BASE,
+ schedules: [weeklyWedSchedule],
+ nowBerlin: localClock(9, 15),
+ lastTakenAt: MONDAY_TAKE,
+ todayEventCount: 0,
+ });
+ expect(res.status).toBe("in_window");
+ expect(res.takenEarlyDaysAgo).toBe(2);
+ });
+
+ it("does not flag takenEarly when the last take was a full period ago", () => {
+ // Previous Wednesday — the prior cycle's regular dose.
+ const res = reduceCurrentWindowStatus({
+ ...BASE,
+ schedules: [weeklyWedSchedule],
+ nowBerlin: localClock(9, 15),
+ lastTakenAt: "2026-06-03T07:05:00.000Z",
+ todayEventCount: 0,
+ });
+ expect(res.status).toBe("in_window");
+ expect(res.takenEarlyDaysAgo).toBeNull();
+ });
+
+ it("does not flag a daily cadence (minute-scale periods stay untouched)", () => {
+ const res = reduceCurrentWindowStatus({
+ ...BASE,
+ schedules: [
+ {
+ windowStart: "09:00",
+ windowEnd: "09:00",
+ daysOfWeek: null,
+ timesOfDay: ["09:00"],
+ },
+ ],
+ nowBerlin: localClock(9, 15),
+ lastTakenAt: "2026-06-09T07:05:00.000Z", // yesterday — normal daily take
+ todayEventCount: 0,
+ });
+ expect(res.status).toBe("in_window");
+ expect(res.takenEarlyDaysAgo).toBeNull();
+ });
+
+ it("rides on the late tier too — an early take must not escalate to overdue", () => {
+ const res = reduceCurrentWindowStatus({
+ ...BASE,
+ schedules: [weeklyWedSchedule],
+ nowBerlin: localClock(11, 30), // past the band + inside lateMinutes
+ lastTakenAt: MONDAY_TAKE,
+ todayEventCount: 0,
+ });
+ expect(res.status).toBe("late");
+ expect(res.takenEarlyDaysAgo).toBe(2);
+ });
+
+ it("evaluates the early-take day in the supplied timezone", () => {
+ // Pacific/Auckland (UTC+12): the same instant lands on different local
+ // days in Berlin vs Auckland near midnight. 2026-06-08T13:00:00Z is
+ // 2026-06-09 01:00 in Auckland (one day before the Wed slot day) —
+ // still inside the weekly period → takenEarly.
+ const res = reduceCurrentWindowStatus({
+ ...BASE,
+ schedules: [weeklyWedSchedule],
+ nowBerlin: localClock(9, 15), // interpreted as Auckland wall clock
+ lastTakenAt: "2026-06-08T13:00:00.000Z",
+ todayEventCount: 0,
+ tz: "Pacific/Auckland",
+ });
+ expect(res.status).toBe("in_window");
+ expect(res.takenEarlyDaysAgo).toBe(1);
+ });
+});
diff --git a/src/lib/medications/intake-slot-dedup.ts b/src/lib/medications/intake-slot-dedup.ts
index b5e06713d..1e475ad9f 100644
--- a/src/lib/medications/intake-slot-dedup.ts
+++ b/src/lib/medications/intake-slot-dedup.ts
@@ -49,6 +49,11 @@ import { annotate } from "@/lib/logging/context";
import { getGlobalBoss } from "@/lib/jobs/boss-instance";
import { DEFAULT_TIMEZONE } from "@/lib/tz/format";
import { resolveCanonicalSlotInstant } from "@/lib/medications/scheduling/resolve-slot-instant";
+import {
+ buildMedicationDayBands,
+ type AttributeIntakeMedication,
+} from "@/lib/medications/scheduling/attribute-intake";
+import type { ScheduleRevisionLike } from "@/lib/medications/scheduling/schedule-eras";
import type {
WorkerMedicationRow,
WorkerScheduleRow,
@@ -89,6 +94,8 @@ type DedupMedication = WorkerMedicationRow & {
userId: string;
timezone: string;
schedules: WorkerScheduleRow[];
+ /** v1.16.9 — archived eras so the band convergence honours old times. */
+ scheduleRevisions: ScheduleRevisionLike[];
};
interface DedupIntakeRow {
@@ -105,6 +112,13 @@ interface DedupIntakeRow {
* ad-hoc). Such a row never joins a snap cluster.
*/
attributionSource: string;
+ /**
+ * v1.16.9 — write origin. The ad-hoc→pending band convergence only
+ * touches API / REMINDER rows (external ingest + the Telegram webhook,
+ * the two paths that historically bare-created `scheduledFor =
+ * takenAt`); a WEB or IMPORT ad-hoc row is a deliberate user shape.
+ */
+ source: string;
}
/**
@@ -197,6 +211,21 @@ export async function dedupeUserIntakeSlots(
scheduleType: true,
cyclicOnWeeks: true,
cyclicOffWeeks: true,
+ // v1.16.9 — the band convergence honours the persisted per-dose
+ // windows (the same lever the write path + read ledger consume).
+ doseWindows: true,
+ },
+ },
+ // v1.16.9 — archived eras: an old ad-hoc row converges against the
+ // schedule that was live at its takenAt, not today's times.
+ scheduleRevisions: {
+ orderBy: { validFrom: "asc" },
+ select: {
+ id: true,
+ validFrom: true,
+ validUntil: true,
+ payload: true,
+ supersededByRevisionId: true,
},
},
},
@@ -235,12 +264,33 @@ export async function dedupeUserIntakeSlots(
createdAt: true,
// v1.16.0 — pin-awareness: a USER_PIN row never joins a cluster.
attributionSource: true,
+ // v1.16.9 — write origin for the ad-hoc→pending convergence gate.
+ source: true,
},
orderBy: { scheduledFor: "asc" },
})) as DedupIntakeRow[];
if (rows.length < 2) continue;
+ // v1.16.9 — heal pass FIRST: converge ad-hoc actioned API/REMINDER
+ // rows onto the pending row of the slot whose minted band contains
+ // the takenAt. The legacy snap pass below only reaches a ±half-window
+ // tolerance, so an 18-minute-early API ingest beside its pending
+ // 09:00 REMINDER row never clustered — the production damage this
+ // backfill exists to repair. The pass mutates `rows` in place
+ // (tombstoned pending rows removed, the winner's `scheduledFor`
+ // normalised) so the snap pass below operates on the healed state.
+ await convergeAdhocRowsOntoPendingSlots({
+ med,
+ rows,
+ userTz,
+ lastIntakeAt,
+ summary,
+ daysToRecompute,
+ });
+
+ if (rows.length < 2) continue;
+
// Group rows by the canonical slot instant they snap to. Rows that
// resolve to `null` are PRN / off-slot — keyed individually so they
// never collapse together.
@@ -402,6 +452,168 @@ export async function dedupeUserIntakeSlots(
return summary;
}
+/**
+ * v1.16.9 — converge ad-hoc actioned rows onto their slot's pending row.
+ *
+ * The healed shape: an external-API or Telegram take historically
+ * bare-created `scheduledFor = takenAt`, leaving the worker-minted
+ * pending REMINDER row open. The pending row later auto-missed, so the
+ * ledger showed an ad-hoc take PLUS a missed slot for one real dose.
+ * The write paths converge since v1.16.9; this pass repairs the rows
+ * already written.
+ *
+ * Deliberately conservative — a pair converges ONLY when:
+ * - the actioned row is ad-hoc shaped (`scheduledFor === takenAt`,
+ * taken, not skipped), source API or REMINDER, and not USER_PIN;
+ * - exactly ONE minted band contains the takenAt (the bands are
+ * disjoint by construction, but a zero- or ambiguous-match take is
+ * left alone);
+ * - the band's anchor carries exactly ONE live row and that row is
+ * unactioned (no takenAt, not skipped — a cron auto-miss flag does
+ * not count as an action: the take proves the miss wrong).
+ *
+ * The actioned row is the dose of record: its `scheduledFor` normalises
+ * to the band anchor and the pending row is tombstoned (soft-deleted,
+ * syncVersion bumped) per the canonical pattern. `rows` is mutated in
+ * place so the caller's snap pass sees the healed state.
+ */
+async function convergeAdhocRowsOntoPendingSlots(input: {
+ med: DedupMedication;
+ rows: DedupIntakeRow[];
+ userTz: string;
+ lastIntakeAt: Date | null;
+ summary: IntakeSlotDedupSummary;
+ daysToRecompute: Set;
+}): Promise {
+ const { med, rows, userTz, lastIntakeAt, summary, daysToRecompute } = input;
+
+ const isRolling = med.schedules.some((s) => s.rollingIntervalDays !== null);
+
+ const adhocCandidates = rows.filter(
+ (r) =>
+ r.takenAt !== null &&
+ !r.skipped &&
+ r.scheduledFor.getTime() === r.takenAt.getTime() &&
+ r.attributionSource !== "USER_PIN" &&
+ (r.source === "API" || r.source === "REMINDER"),
+ );
+ if (adhocCandidates.length === 0) return;
+
+ const medication: AttributeIntakeMedication = {
+ id: med.id,
+ startsOn: med.startsOn,
+ endsOn: med.endsOn,
+ oneShot: med.oneShot,
+ createdAt: med.createdAt,
+ schedules: med.schedules,
+ scheduleRevisions: med.scheduleRevisions ?? [],
+ };
+
+ for (const adhoc of adhocCandidates) {
+ try {
+ const takenAt = adhoc.takenAt as Date;
+ // Rolling cadences anchor their retrospective grid AT each intake;
+ // build the instants from the rows already in memory, EXCLUDING the
+ // candidate itself (its own ad-hoc anchor must not mint the band it
+ // is judged against).
+ const intakeInstants = isRolling
+ ? rows
+ .filter(
+ (r) =>
+ r.id !== adhoc.id &&
+ r.takenAt !== null &&
+ !r.skipped &&
+ r.takenAt.getTime() <= takenAt.getTime(),
+ )
+ .map((r) => r.takenAt as Date)
+ .sort((a, b) => a.getTime() - b.getTime())
+ : undefined;
+
+ const { bands, hasExpectedSlots } = buildMedicationDayBands({
+ medication,
+ userTz,
+ around: takenAt,
+ lastIntakeAt,
+ intakeInstants,
+ now: takenAt,
+ });
+ if (!hasExpectedSlots) continue;
+
+ const t = takenAt.getTime();
+ // The lower bound honours the bounded early grace (`earlyStart`):
+ // an explicit window that starts AT the dose time ("09:00–10:00")
+ // must still converge an 08:42 take — the same reach the write-path
+ // attribution credits. Bands without the field keep the strict
+ // on-time start.
+ const matching = bands.filter(
+ (b) =>
+ t >= (b.earlyStart ?? b.onTimeStart).getTime() &&
+ t <= b.overdueEnd.getTime(),
+ );
+ if (matching.length !== 1) continue; // zero or ambiguous — leave alone.
+ const anchor = matching[0].at;
+ if (anchor.getTime() === adhoc.scheduledFor.getTime()) continue; // same instant — the snap pass owns it.
+
+ const anchorRows = rows.filter(
+ (r) =>
+ r.id !== adhoc.id && r.scheduledFor.getTime() === anchor.getTime(),
+ );
+ if (anchorRows.length !== 1) continue; // empty or double-slot — leave alone.
+ const pending = anchorRows[0];
+ if (pending.takenAt !== null || pending.skipped) continue; // already served.
+
+ // Tombstone the pending row; the take is the dose of record.
+ await prisma.medicationIntakeEvent.updateMany({
+ where: { id: pending.id, deletedAt: null },
+ data: { deletedAt: new Date(), syncVersion: { increment: 1 } },
+ });
+ summary.rowsSoftDeleted += 1;
+
+ const adhocDayInstant = adhoc.scheduledFor;
+ // Normalise the take onto the canonical anchor. Same P2002 guard as
+ // the snap pass: a tombstoned row may already occupy
+ // `(anchor, source)`; when it does the take keeps its own anchor —
+ // the pending row is already gone, so the slot no longer double-counts.
+ try {
+ await prisma.medicationIntakeEvent.update({
+ where: { id: adhoc.id },
+ data: { scheduledFor: anchor, syncVersion: { increment: 1 } },
+ });
+ summary.rowsNormalised += 1;
+ adhoc.scheduledFor = anchor;
+ } catch (normErr) {
+ if (!isP2002(normErr)) throw normErr;
+ annotate({
+ meta: {
+ intake_slot_dedup_converge_collision: true,
+ intake_slot_dedup_medication: med.id,
+ intake_slot_dedup_slot: anchor.toISOString(),
+ },
+ });
+ }
+
+ summary.slotsCollapsed += 1;
+
+ // Both local days can differ for day-scale bands — recompute each.
+ daysToRecompute.add(`${med.id}|${anchor.toISOString()}`);
+ daysToRecompute.add(`${med.id}|${adhocDayInstant.toISOString()}`);
+
+ // Mutate the in-memory rows so the snap pass sees the healed state.
+ const pendingIdx = rows.findIndex((r) => r.id === pending.id);
+ if (pendingIdx >= 0) rows.splice(pendingIdx, 1);
+ } catch (pairErr) {
+ annotate({
+ meta: {
+ intake_slot_dedup_converge_failed: true,
+ intake_slot_dedup_medication: med.id,
+ intake_slot_dedup_error:
+ pairErr instanceof Error ? pairErr.message : String(pairErr),
+ },
+ });
+ }
+ }
+}
+
/**
* Discovery pass — runs at worker boot and on the daily cron tick (the
* cron payload omits `userId`; the worker handler dispatches here). Finds
@@ -444,6 +656,15 @@ export async function enqueueBootTimeIntakeSlotDedup(): Promise<{
// `(user_id, medication_id, scheduled_for)`. The window absorbs the
// sub-minute iOS-vs-server drift; the per-user pass re-checks
// precisely so a wider-than-needed window only costs idle jobs.
+ //
+ // v1.16.9 — second arm: the ad-hoc→pending heal pattern. An actioned
+ // ad-hoc row (`scheduled_for = taken_at`) beside an unactioned row on
+ // the same medication can sit up to the widest band reach apart
+ // (weekly on-time 1d + overdue 4d ≈ 5 days; 475200 s adds half a day
+ // of slack) — far outside the 2-minute drift arm, which is why the
+ // 18-minute API/REMINDER pairs were never enqueued. The per-user pass
+ // re-checks by exact band membership, so the wide arm only costs idle
+ // jobs.
const users = await prisma.$queryRaw>`
SELECT DISTINCT a."user_id" AS id
FROM "medication_intake_events" a
@@ -453,7 +674,18 @@ export async function enqueueBootTimeIntakeSlotDedup(): Promise<{
AND a."id" <> b."id"
AND a."deleted_at" IS NULL
AND b."deleted_at" IS NULL
- AND abs(extract(epoch FROM (a."scheduled_for" - b."scheduled_for"))) <= 120
+ AND (
+ abs(extract(epoch FROM (a."scheduled_for" - b."scheduled_for"))) <= 120
+ OR (
+ a."taken_at" IS NOT NULL
+ AND a."scheduled_for" = a."taken_at"
+ AND a."skipped" = false
+ AND a."source" IN ('API', 'REMINDER')
+ AND b."taken_at" IS NULL
+ AND b."skipped" = false
+ AND abs(extract(epoch FROM (a."scheduled_for" - b."scheduled_for"))) <= 475200
+ )
+ )
`;
if (users.length === 0) {
diff --git a/src/lib/medications/scheduling/__tests__/attribution.test.ts b/src/lib/medications/scheduling/__tests__/attribution.test.ts
index 9d2b40a0f..227f30e3f 100644
--- a/src/lib/medications/scheduling/__tests__/attribution.test.ts
+++ b/src/lib/medications/scheduling/__tests__/attribution.test.ts
@@ -96,8 +96,17 @@ describe("attributeIntakeToSlot — summer (CEST)", () => {
expect(r?.status).toBe("on_time");
});
- it("a take at 17:30 is ad-hoc (past the 07:00 tail, before the 19:00 window)", () => {
- expect(attributeIntakeToSlot(at(day, 17, 30), bands)).toBeNull();
+ it("a take at 17:30 credits the 19:00 slot through the bounded early grace (v1.16.9)", () => {
+ // 30 min before the 18:00 on-time start — inside the 60-min early
+ // grace, so a slightly-early take credits its slot instead of
+ // orphaning ad-hoc while the slot later reads missed.
+ const r = attributeIntakeToSlot(at(day, 17, 30), bands);
+ expect(r?.band.timeOfDay).toBe("19:00");
+ expect(r?.status).toBe("on_time");
+ });
+
+ it("a take at 16:30 stays ad-hoc (beyond the 60-min early grace)", () => {
+ expect(attributeIntakeToSlot(at(day, 16, 30), bands)).toBeNull();
});
});
@@ -166,3 +175,73 @@ describe("attributeIntakeToSlot — configurable window widens on-time", () => {
expect(r?.status).toBe("on_time");
});
});
+
+/**
+ * v1.16.9 — bounded early grace ahead of the on-time band.
+ *
+ * A window configured to start AT the dose time ("09:00–10:00") refused
+ * an 08:42 take: it orphaned ad-hoc and the slot read missed. Takes up to
+ * 60 min before `onTimeStart` now credit the slot; the reach is capped at
+ * the previous slot's `overdueEnd` so a take inside the prior dose's late
+ * tail is never re-claimed.
+ */
+describe("attributeIntakeToSlot — bounded early grace (v1.16.9)", () => {
+ const day = new Date("2026-06-08T12:00:00Z");
+
+ function nineToTenWindow(): SlotWindowInput {
+ return {
+ at: localHmAsUtc(day, TZ, 9, 0),
+ timeOfDay: "09:00",
+ onTimeStart: localHmAsUtc(day, TZ, 9, 0),
+ onTimeEnd: localHmAsUtc(day, TZ, 10, 0),
+ lateGraceMs: 180 * MIN,
+ };
+ }
+
+ it("an 08:42 take credits the 09:00 slot whose window starts AT 09:00", () => {
+ const bands = buildSlotBands([nineToTenWindow()]);
+ const r = attributeIntakeToSlot(at(day, 8, 42), bands);
+ expect(r?.band.timeOfDay).toBe("09:00");
+ expect(r?.status).toBe("on_time");
+ });
+
+ it("a take more than 60 min before the window start stays ad-hoc", () => {
+ const bands = buildSlotBands([nineToTenWindow()]);
+ expect(attributeIntakeToSlot(at(day, 7, 55), bands)).toBeNull();
+ });
+
+ it("the early grace never crosses into the previous slot's band", () => {
+ // 06:00 slot with a long late tail reaching to 09:00 (capped exactly
+ // at the 09:00 window start) + the 09:00–10:00 window. A take at
+ // 08:42 sits inside the 06:00 slot's tail — it must stay attributed
+ // LATE to the 06:00 slot, never early-claimed by the 09:00 slot.
+ const slots: SlotWindowInput[] = [
+ {
+ at: localHmAsUtc(day, TZ, 6, 0),
+ timeOfDay: "06:00",
+ onTimeStart: localHmAsUtc(day, TZ, 5, 30),
+ onTimeEnd: localHmAsUtc(day, TZ, 6, 30),
+ lateGraceMs: 600 * MIN, // capped at the next window's start
+ },
+ nineToTenWindow(),
+ ];
+ const bands = buildSlotBands(slots);
+ // The cap binds: the 09:00 band's early reach starts where the 06:00
+ // tail ends.
+ expect(bands[1].earlyStart.toISOString()).toBe(
+ bands[0].overdueEnd.toISOString(),
+ );
+ const r = attributeIntakeToSlot(at(day, 8, 42), bands);
+ expect(r?.band.timeOfDay).toBe("06:00");
+ expect(r?.status).toBe("late");
+ });
+
+ it("isLastIntakeInBand suppression mirrors the grace (no take-now after an 08:42 take)", () => {
+ // Covered at the card level: see window-status — this pins the band
+ // shape the suppression relies on (earlyStart <= onTimeStart always).
+ const bands = buildSlotBands([nineToTenWindow()]);
+ expect(bands[0].earlyStart.getTime()).toBeLessThanOrEqual(
+ bands[0].onTimeStart.getTime(),
+ );
+ });
+});
diff --git a/src/lib/medications/scheduling/__tests__/next-due.test.ts b/src/lib/medications/scheduling/__tests__/next-due.test.ts
index 495fecd35..3a9dec442 100644
--- a/src/lib/medications/scheduling/__tests__/next-due.test.ts
+++ b/src/lib/medications/scheduling/__tests__/next-due.test.ts
@@ -11,12 +11,22 @@
*/
import { describe, expect, it } from "vitest";
-import { computeDisplayDue, computeNextDueAt } from "../next-due";
+import {
+ computeDisplayDue,
+ computeNextDueAt,
+ toResolvedSlotMark,
+ type ResolvedSlotMark,
+} from "../next-due";
import type {
WorkerMedicationRow,
WorkerScheduleRow,
} from "../worker-helpers";
+/** A slot-anchored resolved mark (the write paths' canonical shape). */
+function mark(at: Date): ResolvedSlotMark {
+ return { at, slotAnchored: true };
+}
+
function d(iso: string): Date {
return new Date(iso);
}
@@ -155,8 +165,8 @@ describe("computeNextDueAt — skip resolved slots (twice-daily)", () => {
userTz: BERLIN,
lastIntakeAt: d("2026-06-10T15:30:00Z"),
resolvedSlots: [
- d("2026-06-10T05:00:00Z"), // today 07:00 Berlin
- d("2026-06-10T17:00:00Z"), // today 19:00 Berlin
+ mark(d("2026-06-10T05:00:00Z")), // today 07:00 Berlin
+ mark(d("2026-06-10T17:00:00Z")), // today 19:00 Berlin
],
});
expect(next).not.toBeNull();
@@ -173,7 +183,7 @@ describe("computeNextDueAt — skip resolved slots (twice-daily)", () => {
now,
userTz: BERLIN,
lastIntakeAt: d("2026-06-10T07:13:00Z"),
- resolvedSlots: [d("2026-06-10T05:00:00Z")], // only today 07:00
+ resolvedSlots: [mark(d("2026-06-10T05:00:00Z"))], // only today 07:00
});
expect(next).not.toBeNull();
expect(next!.toISOString()).toBe("2026-06-10T17:00:00.000Z"); // today 19:00
@@ -315,7 +325,7 @@ describe("computeDisplayDue — open overdue slot", () => {
now,
userTz: BERLIN,
lastIntakeAt: null,
- resolvedSlots: [d("2026-06-10T19:00:00Z")],
+ resolvedSlots: [mark(d("2026-06-10T19:00:00Z"))],
});
expect(due).not.toBeNull();
expect(due!.overdue).toBe(false);
@@ -336,3 +346,137 @@ describe("computeDisplayDue — open overdue slot", () => {
expect(due!.overdue).toBe(false);
});
});
+
+/**
+ * v1.16.9 — an AD-HOC row (`scheduledFor === takenAt`) must never
+ * ±6h-resolve a DIFFERENT slot. The proven failure: twice-daily 08:00 /
+ * 20:00 Berlin, an ad-hoc take at 14:30 sat within 6h of tonight's 20:00
+ * anchor and resolved it — the genuinely-due dose disappeared from the
+ * card while the ledger still counted the slot missed.
+ */
+describe("resolved-slot marks — ad-hoc rows only match their own anchor", () => {
+ const medication = makeMedication();
+ // 08:00 / 20:00 Berlin (CEST): 06:00Z / 18:00Z.
+ function schedule(): WorkerScheduleRow {
+ return {
+ id: "sched-2x",
+ windowStart: "08:00",
+ windowEnd: "20:00",
+ daysOfWeek: null,
+ timesOfDay: ["08:00", "20:00"],
+ reminderGraceMinutes: null,
+ rrule: null,
+ rollingIntervalDays: null,
+ scheduleType: "SCHEDULED",
+ cyclicOnWeeks: null,
+ cyclicOffWeeks: null,
+ };
+ }
+ const ADHOC_1430 = d("2026-06-10T12:30:00Z"); // 14:30 Berlin
+
+ it("a 14:30 ad-hoc take leaves tonight's 20:00 slot due", () => {
+ const now = d("2026-06-10T15:00:00Z"); // 17:00 Berlin
+ const next = computeNextDueAt({
+ medication,
+ schedules: [schedule()],
+ now,
+ userTz: BERLIN,
+ lastIntakeAt: ADHOC_1430,
+ resolvedSlots: [
+ // The morning slot was genuinely taken (slot-anchored row)…
+ mark(d("2026-06-10T06:00:00Z")),
+ // …and the 14:30 take recorded ad-hoc (`scheduledFor === takenAt`).
+ toResolvedSlotMark({ scheduledFor: ADHOC_1430, takenAt: ADHOC_1430 }),
+ ],
+ });
+ expect(next).not.toBeNull();
+ // Tonight's 20:00 Berlin (18:00Z) stays due — the ad-hoc row must not
+ // resolve it across the radius.
+ expect(next!.toISOString()).toBe("2026-06-10T18:00:00.000Z");
+ });
+
+ it("a 14:30 ad-hoc take does not suppress the 20:00 overdue pill either", () => {
+ const now = d("2026-06-10T19:00:00Z"); // 21:00 Berlin — inside the late tail
+ const due = computeDisplayDue({
+ medication,
+ schedules: [schedule()],
+ now,
+ userTz: BERLIN,
+ lastIntakeAt: ADHOC_1430,
+ resolvedSlots: [
+ mark(d("2026-06-10T06:00:00Z")),
+ toResolvedSlotMark({ scheduledFor: ADHOC_1430, takenAt: ADHOC_1430 }),
+ ],
+ });
+ expect(due).not.toBeNull();
+ expect(due!.overdue).toBe(true);
+ expect(due!.at.toISOString()).toBe("2026-06-10T18:00:00.000Z");
+ });
+
+ it("a slot-anchored attributed row still resolves its slot across drift", () => {
+ const now = d("2026-06-10T19:00:00Z"); // 21:00 Berlin
+ const due = computeDisplayDue({
+ medication,
+ schedules: [schedule()],
+ now,
+ userTz: BERLIN,
+ lastIntakeAt: d("2026-06-10T18:05:00Z"),
+ resolvedSlots: [
+ mark(d("2026-06-10T06:00:00Z")),
+ // Attributed take: scheduledFor on the anchor, takenAt 20:05.
+ toResolvedSlotMark({
+ scheduledFor: d("2026-06-10T18:00:00Z"),
+ takenAt: d("2026-06-10T18:05:00Z"),
+ }),
+ ],
+ });
+ expect(due).not.toBeNull();
+ expect(due!.overdue).toBe(false);
+ // Both today's slots resolved → tomorrow's 08:00 Berlin (06:00Z).
+ expect(due!.at.toISOString()).toBe("2026-06-11T06:00:00.000Z");
+ });
+
+ it("an ad-hoc row sitting exactly on the anchor still resolves that slot", () => {
+ const now = d("2026-06-10T19:00:00Z");
+ const due = computeDisplayDue({
+ medication,
+ schedules: [schedule()],
+ now,
+ userTz: BERLIN,
+ lastIntakeAt: d("2026-06-10T18:00:00Z"),
+ resolvedSlots: [
+ mark(d("2026-06-10T06:00:00Z")),
+ // Take recorded at the exact anchor instant — ad-hoc shaped but ON
+ // the slot; the near-exact epsilon keeps it resolving.
+ toResolvedSlotMark({
+ scheduledFor: d("2026-06-10T18:00:00Z"),
+ takenAt: d("2026-06-10T18:00:00Z"),
+ }),
+ ],
+ });
+ expect(due).not.toBeNull();
+ expect(due!.overdue).toBe(false);
+ expect(due!.at.toISOString()).toBe("2026-06-11T06:00:00.000Z");
+ });
+
+ it("behaves identically in a non-European zone (Pacific/Auckland)", () => {
+ const AUCKLAND = "Pacific/Auckland"; // UTC+12 in June (NZST)
+ // 08:00 / 20:00 Auckland on 2026-06-10 = 2026-06-09T20:00Z / 2026-06-10T08:00Z.
+ const adhoc = d("2026-06-10T02:30:00Z"); // 14:30 Auckland
+ const now = d("2026-06-10T09:00:00Z"); // 21:00 Auckland
+ const due = computeDisplayDue({
+ medication,
+ schedules: [schedule()],
+ now,
+ userTz: AUCKLAND,
+ lastIntakeAt: adhoc,
+ resolvedSlots: [
+ mark(d("2026-06-09T20:00:00Z")),
+ toResolvedSlotMark({ scheduledFor: adhoc, takenAt: adhoc }),
+ ],
+ });
+ expect(due).not.toBeNull();
+ expect(due!.overdue).toBe(true);
+ expect(due!.at.toISOString()).toBe("2026-06-10T08:00:00.000Z");
+ });
+});
diff --git a/src/lib/medications/scheduling/attribution.ts b/src/lib/medications/scheduling/attribution.ts
index 7d8b705bb..3c69488c9 100644
--- a/src/lib/medications/scheduling/attribution.ts
+++ b/src/lib/medications/scheduling/attribution.ts
@@ -25,6 +25,8 @@
* this module timezone-agnostic and trivially testable.
*/
+import { DOSE_WINDOW_DEFAULTS } from "@/lib/medications/scheduling/dose-window-defaults";
+
/** Per-slot window the caller supplies (bounds already minted as instants). */
export interface SlotWindowInput {
/** Canonical anchor instant for the slot (labelling / next-due / pairing). */
@@ -39,10 +41,29 @@ export interface SlotWindowInput {
lateGraceMs: number;
}
+/**
+ * v1.16.9 — bounded early grace ahead of the on-time band. A user who
+ * configures a window to start AT the dose time ("09:00–10:00") would
+ * otherwise have an 08:42 take refused and orphaned ad-hoc while the
+ * slot read missed. A take up to this far before `onTimeStart` still
+ * credits the slot (as on-time); the reach is capped at the PREVIOUS
+ * slot's `overdueEnd` so it can never claim a take that belongs to the
+ * prior dose's late tail. Sourced from the shared dose-window-defaults
+ * leaf (client-safe) so the card pill suppression reads the same width.
+ */
+export const EARLY_GRACE_MS =
+ DOSE_WINDOW_DEFAULTS.earlyGraceMinutes * 60 * 1000;
+
/** A slot window with its (capped) late-tail cutoff resolved. */
export interface SlotBand extends SlotWindowInput {
/** Cutoff past which a take no longer pairs to this slot (capped). */
overdueEnd: Date;
+ /**
+ * Earliest instant a take still credits this slot (the bounded early
+ * grace before `onTimeStart`, capped at the previous slot's
+ * `overdueEnd`).
+ */
+ earlyStart: Date;
}
export type AttributionStatus = "on_time" | "late";
@@ -59,7 +80,7 @@ export interface AttributionResult {
*/
export function buildSlotBands(slots: SlotWindowInput[]): SlotBand[] {
const sorted = [...slots].sort((a, b) => a.at.getTime() - b.at.getTime());
- return sorted.map((slot, i) => {
+ const withTails = sorted.map((slot, i) => {
let overdueEnd = slot.onTimeEnd.getTime() + slot.lateGraceMs;
const next = sorted[i + 1];
if (next) {
@@ -71,6 +92,19 @@ export function buildSlotBands(slots: SlotWindowInput[]): SlotBand[] {
overdueEnd = Math.max(overdueEnd, slot.onTimeEnd.getTime());
return { ...slot, overdueEnd: new Date(overdueEnd) };
});
+ // Second pass — the early reach is bounded by the PREVIOUS slot's
+ // resolved tail, so it never claims a take inside the prior dose's
+ // band. The previous `overdueEnd` is already capped at this slot's
+ // `onTimeStart`, so `earlyStart <= onTimeStart` holds by construction.
+ return withTails.map((band, i) => {
+ let earlyStart = band.onTimeStart.getTime() - EARLY_GRACE_MS;
+ const prev = withTails[i - 1];
+ if (prev) {
+ earlyStart = Math.max(earlyStart, prev.overdueEnd.getTime());
+ }
+ earlyStart = Math.min(earlyStart, band.onTimeStart.getTime());
+ return { ...band, earlyStart: new Date(earlyStart) };
+ });
}
/**
@@ -90,7 +124,10 @@ export function attributeIntakeToSlot(
null;
for (const band of bands) {
- const onStart = band.onTimeStart.getTime();
+ // v1.16.9 — the bounded early grace extends the on-time capture below
+ // `onTimeStart` (never into the previous slot's band — `buildSlotBands`
+ // caps it). Hand-built bands without the field keep the strict start.
+ const onStart = (band.earlyStart ?? band.onTimeStart).getTime();
const onEnd = band.onTimeEnd.getTime();
const overdueEnd = band.overdueEnd.getTime();
diff --git a/src/lib/medications/scheduling/dose-window-defaults.ts b/src/lib/medications/scheduling/dose-window-defaults.ts
index 3831bf840..668501f68 100644
--- a/src/lib/medications/scheduling/dose-window-defaults.ts
+++ b/src/lib/medications/scheduling/dose-window-defaults.ts
@@ -20,6 +20,15 @@
export const DOSE_WINDOW_DEFAULTS = {
/** Daily / intraday on-time half-width around the target instant (min). */
dailyOnTimeMinutes: 60,
+ /**
+ * Bounded early grace ahead of a dose's on-time window (min). A take up
+ * to this far before the window start still credits the slot (the
+ * attribution caps the reach at the previous slot's overdue end).
+ * Single source for the write-path attribution AND the card pill's
+ * last-intake suppression, so the two can never disagree on how early
+ * a take may land.
+ */
+ earlyGraceMinutes: 60,
/**
* Daily / intraday overdue tail past the on-time window (min). A dose
* taken inside `[onTime, onTime + overdue]` still counts; beyond it the
diff --git a/src/lib/medications/scheduling/next-due.ts b/src/lib/medications/scheduling/next-due.ts
index 4f646770a..21cb71e94 100644
--- a/src/lib/medications/scheduling/next-due.ts
+++ b/src/lib/medications/scheduling/next-due.ts
@@ -29,6 +29,63 @@ import { DOSE_WINDOW_DEFAULTS } from "@/lib/medications/scheduling/dose-window-d
*/
const RESOLVE_RADIUS_MS = 6 * 60 * 60 * 1000;
+/**
+ * v1.16.9 — exact-match slop for an AD-HOC row. An ad-hoc take anchors
+ * `scheduledFor = takenAt` on its own instant, so it can only resolve a
+ * slot it actually sits on (sub-minute drift absorbed); letting it use
+ * the ±6h radius hid genuinely-due slots — a 14:30 ad-hoc take resolved
+ * tonight's 20:00 dose while the ledger still counted that slot missed.
+ */
+const ADHOC_RESOLVE_EPSILON_MS = 60 * 1000;
+
+/**
+ * A row that resolves a slot (taken / deliberately skipped /
+ * cron-auto-missed), with its anchoring shape preserved.
+ *
+ * `slotAnchored: false` marks the ad-hoc shape (`scheduledFor ===
+ * takenAt`): such a row resolves a slot only on a near-exact anchor
+ * match, never across the ±6h radius. Slot-anchored rows (the write
+ * paths snap their `scheduledFor` to the canonical slot instant) keep
+ * the defensive radius.
+ */
+export interface ResolvedSlotMark {
+ at: Date;
+ slotAnchored: boolean;
+}
+
+/**
+ * Map a resolved intake row to its `ResolvedSlotMark`. The ad-hoc shape
+ * is detectable only for taken rows (`scheduledFor === takenAt` to the
+ * millisecond — the documented standalone-insert contract); skips and
+ * auto-misses anchor on their slot by construction.
+ */
+export function toResolvedSlotMark(row: {
+ scheduledFor: Date;
+ takenAt: Date | null;
+}): ResolvedSlotMark {
+ return {
+ at: row.scheduledFor,
+ slotAnchored:
+ row.takenAt === null ||
+ row.takenAt.getTime() !== row.scheduledFor.getTime(),
+ };
+}
+
+function buildIsResolved(
+ resolved: ResolvedSlotMark[],
+): (slotAt: Date) => boolean {
+ return (slotAt: Date): boolean => {
+ const slot = slotAt.getTime();
+ for (const r of resolved) {
+ const radius = r.slotAnchored
+ ? RESOLVE_RADIUS_MS
+ : ADHOC_RESOLVE_EPSILON_MS;
+ if (Math.abs(r.at.getTime() - slot) <= radius) return true;
+ }
+ return false;
+ };
+}
+
/**
* v1.16.4 — how far back the open-overdue search mints bands. The widest
* possible band reach is a weekly slot's on-time half-width plus its
@@ -57,21 +114,15 @@ export function computeNextDueAt(input: {
* these so a twice-daily med whose remaining slots today are all logged
* advances to the next genuinely-open slot (tomorrow's first dose) instead
* of re-surfacing a resolved present/past slot. Omit for the legacy
- * purely-time-anchored next-due.
+ * purely-time-anchored next-due. v1.16.9 — each mark carries its
+ * anchoring shape; ad-hoc rows only resolve on a near-exact match.
*/
- resolvedSlots?: Date[];
+ resolvedSlots?: ResolvedSlotMark[];
}): Date | null {
const { medication, schedules, now, userTz, lastIntakeAt } = input;
if (schedules.length === 0) return null;
- const resolved = input.resolvedSlots ?? [];
- const isResolved = (slotAt: Date): boolean => {
- const slot = slotAt.getTime();
- for (const r of resolved) {
- if (Math.abs(r.getTime() - slot) <= RESOLVE_RADIUS_MS) return true;
- }
- return false;
- };
+ const isResolved = buildIsResolved(input.resolvedSlots ?? []);
const ctx = buildRecurrenceContext({ medication, userTz, lastIntakeAt });
let earliest: Date | null = null;
@@ -113,7 +164,7 @@ export interface ComputeDisplayDueInput {
now: Date;
userTz: string;
lastIntakeAt: Date | null;
- resolvedSlots?: Date[];
+ resolvedSlots?: ResolvedSlotMark[];
/**
* Floor of the CURRENT schedule era (the newest revision's `validUntil`),
* when the medication has archived revisions. The overdue search mints
@@ -148,14 +199,7 @@ function findOpenOverdueSlot(input: ComputeDisplayDueInput): Date | null {
const { medication, schedules, now, userTz, lastIntakeAt } = input;
if (schedules.length === 0) return null;
- const resolved = input.resolvedSlots ?? [];
- const isResolved = (slotAt: Date): boolean => {
- const slot = slotAt.getTime();
- for (const r of resolved) {
- if (Math.abs(r.getTime() - slot) <= RESOLVE_RADIUS_MS) return true;
- }
- return false;
- };
+ const isResolved = buildIsResolved(input.resolvedSlots ?? []);
let floor = new Date(now.getTime() - OVERDUE_LOOKBACK_MS);
if (input.eraStart && input.eraStart.getTime() > floor.getTime()) {
diff --git a/src/lib/medications/scheduling/recurrence.ts b/src/lib/medications/scheduling/recurrence.ts
index 527026b53..2fba3b485 100644
--- a/src/lib/medications/scheduling/recurrence.ts
+++ b/src/lib/medications/scheduling/recurrence.ts
@@ -117,6 +117,18 @@ export interface RecurrenceContext {
* Latest `MedicationIntakeEvent.takenAt` for this medication.
* Used only by rolling schedules. Null when the user has never
* logged an intake (rolling then anchors on `startsOn ?? createdAt`).
+ *
+ * Skip semantics (documented decision, v1.16.9): a deliberate SKIP
+ * does NOT advance the rolling anchor. A skipped row carries
+ * `takenAt: null`, so every `lastIntakeAt` feeder query
+ * (`takenAt: { not: null }`) excludes it by construction, and the
+ * next due stays `previous take + N` — the skipped dose keeps
+ * surfacing as due until a real take re-anchors the grid. Advancing
+ * the anchor from the skipped instant instead would silently shift
+ * the whole future grid off the user's established rhythm; if that
+ * trade-off is ever revisited, every `lastIntakeAt` feeder (the
+ * projector, the reminder worker, the list route, the write-path
+ * resolvers, the dedup pass) must change together.
*/
lastIntakeAt: Date | null;
}
diff --git a/src/lib/medications/scheduling/slot-upsert.ts b/src/lib/medications/scheduling/slot-upsert.ts
index a0df2d2c8..f50e55ac0 100644
--- a/src/lib/medications/scheduling/slot-upsert.ts
+++ b/src/lib/medications/scheduling/slot-upsert.ts
@@ -54,8 +54,13 @@ export interface ApplyCanonicalSlotWriteInput {
isExplicitTaken: boolean;
isExplicitSkip: boolean;
idempotencyKey: string | null;
- /** Source to stamp on a freshly-created slot row. */
- createSource: "WEB" | "API";
+ /**
+ * Source to stamp on a freshly-created slot row. `REMINDER` is the
+ * Telegram-webhook path — its take / skip confirmations converge onto
+ * the worker-minted pending row like every other write, and a fresh
+ * create keeps the historical reminder provenance.
+ */
+ createSource: "WEB" | "API" | "REMINDER";
/**
* v1.8.5 — resolved + server-validated injection site to persist on a
* taken write. `null` = no site (the column stays / is set NULL). Only
diff --git a/src/lib/medications/window-status.ts b/src/lib/medications/window-status.ts
index d97e2f2f8..0c8ad5f18 100644
--- a/src/lib/medications/window-status.ts
+++ b/src/lib/medications/window-status.ts
@@ -87,6 +87,18 @@ export interface CurrentWindowStatus {
schedule: Schedule | null;
/** Non-null exactly when `status` is non-null. */
window: MatchedDoseWindow | null;
+ /**
+ * v1.16.9 — non-null when the matched schedule is a DAY-SCALE cadence
+ * (weekly / N-weekly injectable) and a recent actioned take exists
+ * inside the current cadence period but on an earlier day. The dose is
+ * already on board: the card must render last-dose context instead of
+ * the "take now" / overdue prompt — a full take prompt on the slot day
+ * is a double-dose prompt. The value is the whole local days since
+ * that take, so the pill copy stays factual (the take may have been an
+ * early shot OR the previous slot served late — the day distance does
+ * not distinguish). Always null when `status` is null.
+ */
+ takenEarlyDaysAgo: number | null;
}
/**
@@ -303,11 +315,28 @@ function getScheduleStatus(
return best;
}
+/**
+ * v1.16.9 — the attribution module's bounded early grace: a take
+ * slightly before the on-time band still credits the slot, so the pill
+ * suppression must accept it too (an 08:42 take for a 09:00-window slot
+ * must not leave "take now" burning at 09:05). Read from the shared
+ * dose-window-defaults leaf — the same constant the write-path
+ * attribution derives `EARLY_GRACE_MS` from — so the two surfaces can
+ * never disagree.
+ */
+const EARLY_GRACE_MINUTES = DOSE_WINDOW_DEFAULTS.earlyGraceMinutes;
+
function isLastIntakeInBand(
lastTakenAt: string | null,
band: DoseWindowBounds,
nowLocal: Date,
tz: string,
+ /**
+ * Lower bound (minutes-of-day) the early grace may not cross — the end
+ * of the schedule's previous dose band, so a take belonging to the
+ * prior dose never suppresses this one. Defaults to 0 (no earlier band).
+ */
+ earlyFloorMins = 0,
): boolean {
if (!lastTakenAt) return false;
@@ -330,7 +359,81 @@ function isLastIntakeInBand(
? intakeMins + 24 * 60
: intakeMins;
- return adjustedIntake >= band.startMins && adjustedIntake <= band.endMins;
+ const startWithGrace = Math.max(
+ band.startMins - EARLY_GRACE_MINUTES,
+ earlyFloorMins,
+ 0,
+ );
+ return adjustedIntake >= startWithGrace && adjustedIntake <= band.endMins;
+}
+
+/**
+ * v1.16.9 — day-scale cadence detection for the taken-early downgrade.
+ *
+ * A schedule whose dose days sit ≥ 2 days apart (a single weekday, a
+ * sparse Mo/Th pattern, an N-weekly interval) is day-scale: one dose
+ * covers a multi-day period, so a take earlier in the period must inform
+ * the slot-day pill. Daily / near-daily patterns (minute-scale) return
+ * `dayScale: false` — their period is a day and the same-day band checks
+ * already cover them. `periodDays` is the smallest gap between
+ * consecutive dose days (the span one dose covers).
+ */
+function dayScaleCadence(daysOfWeek: string | null): {
+ dayScale: boolean;
+ periodDays: number;
+} {
+ const recurrence = parseScheduleRecurrence(daysOfWeek);
+ const days = [...new Set(recurrence.daysOfWeek)].sort((a, b) => a - b);
+ if (days.length === 0) return { dayScale: false, periodDays: 0 };
+ const intervalWeeks = Math.max(1, recurrence.intervalWeeks ?? 1);
+ if (days.length === 1) {
+ return { dayScale: true, periodDays: 7 * intervalWeeks };
+ }
+ let minGap = Infinity;
+ for (let i = 1; i < days.length; i++) {
+ minGap = Math.min(minGap, days[i] - days[i - 1]);
+ }
+ // Wrap from the week's last dose day to the next cycle's first.
+ const wrapGap = days[0] + 7 * intervalWeeks - days[days.length - 1];
+ minGap = Math.min(minGap, wrapGap);
+ return { dayScale: minGap >= 2, periodDays: minGap };
+}
+
+/**
+ * Whole local days since the last actioned take when it lies on an
+ * EARLIER local day inside the current cadence period — the shape the
+ * taken-early downgrade fires on — else `null`. A same-day take is the
+ * in-band suppression's job; a take a full period (or more) ago is the
+ * previous cycle's dose. The day count rides into the pill copy, which
+ * stays neutral ("last dose {n} days ago"): the period may have opened
+ * with an early shot OR the previous slot served late, and the distance
+ * alone cannot tell the two apart.
+ */
+function earlyTakeDaysAgo(
+ lastTakenAt: string | null,
+ nowLocal: Date,
+ tz: string,
+ periodDays: number,
+): number | null {
+ if (!lastTakenAt || periodDays < 2) return null;
+ const intake = toZonedDate(new Date(lastTakenAt), tz);
+ const dayMs = 24 * 60 * 60 * 1000;
+ const intakeDay = Math.floor(
+ new Date(
+ intake.getFullYear(),
+ intake.getMonth(),
+ intake.getDate(),
+ ).getTime() / dayMs,
+ );
+ const nowDay = Math.floor(
+ new Date(
+ nowLocal.getFullYear(),
+ nowLocal.getMonth(),
+ nowLocal.getDate(),
+ ).getTime() / dayMs,
+ );
+ const diff = nowDay - intakeDay;
+ return diff >= 1 && diff < periodDays ? diff : null;
}
/**
@@ -388,32 +491,39 @@ function countPassedDoses(
* the default are the legacy Berlin contract — callers that serve other
* timezones pass their own.
*/
-export function reduceCurrentWindowStatus(
- options: {
- schedules: Schedule[];
- nowBerlin: Date;
- lateMinutes: number;
- missedMinutes: number;
- active: boolean;
- lastTakenAt: string | null;
- todayEventCount: number;
- /** IANA timezone matching `nowBerlin`'s conversion; defaults to Berlin. */
- tz?: string;
- /**
- * v1.16.6 — the server display-due gate. `undefined` keeps the legacy
- * purely band-derived behaviour (callers without the list payload);
- * `null` means the server found NO upcoming slot (paused / ended /
- * one-shot past) so no pill renders at all. With a gate present:
- * - `overdue: false` (next unresolved slot in the future) suppresses
- * late / very_late outright and allows in_window only when the due
- * instant falls on the current local day — a rolling cadence whose
- * next dose is tomorrow stays calm today;
- * - `overdue: true` keeps the band-derived escalation (the slot is
- * genuinely in its catch-up tail).
- */
- nextDue?: NextDueGate | null;
- },
-): CurrentWindowStatus {
+export function reduceCurrentWindowStatus<
+ Schedule extends ScheduleWindowInput,
+>(options: {
+ schedules: Schedule[];
+ nowBerlin: Date;
+ lateMinutes: number;
+ missedMinutes: number;
+ active: boolean;
+ lastTakenAt: string | null;
+ /**
+ * v1.16.9 — number of ACTIONED intake events today (taken or
+ * explicitly skipped). The server list feeder counts only actioned
+ * rows: the dashboard projector mints a pending row for every slot of
+ * the day, so an all-rows count covered every passed dose after any
+ * dashboard visit and the overdue pill went dark nondeterministically.
+ */
+ todayEventCount: number;
+ /** IANA timezone matching `nowBerlin`'s conversion; defaults to Berlin. */
+ tz?: string;
+ /**
+ * v1.16.6 — the server display-due gate. `undefined` keeps the legacy
+ * purely band-derived behaviour (callers without the list payload);
+ * `null` means the server found NO upcoming slot (paused / ended /
+ * one-shot past) so no pill renders at all. With a gate present:
+ * - `overdue: false` (next unresolved slot in the future) suppresses
+ * late / very_late outright and allows in_window only when the due
+ * instant falls on the current local day — a rolling cadence whose
+ * next dose is tomorrow stays calm today;
+ * - `overdue: true` keeps the band-derived escalation (the slot is
+ * genuinely in its catch-up tail).
+ */
+ nextDue?: NextDueGate | null;
+}): CurrentWindowStatus {
const {
schedules,
nowBerlin,
@@ -430,6 +540,7 @@ export function reduceCurrentWindowStatus(
status: null,
schedule: null,
window: null,
+ takenEarlyDaysAgo: null,
};
if (!active) return none;
if (nextDue === null) return none;
@@ -465,14 +576,36 @@ export function reduceCurrentWindowStatus(
// intake events for the day.
if (hit.status !== "in_window" && !hasUncoveredOverdue) return best;
// Don't show in_window if last intake is already within this band
- // today.
+ // today (including the bounded early grace, floored at the end of
+ // the schedule's previous dose band so a prior dose's take never
+ // suppresses this one).
+ const earlyFloorMins = resolveDoseWindows(s).reduce(
+ (floor, b) =>
+ b.endMins <= hit.band.startMins && b.endMins > floor
+ ? b.endMins
+ : floor,
+ 0,
+ );
if (
hit.status === "in_window" &&
- isLastIntakeInBand(lastTakenAt, hit.band, nowBerlin, tz)
+ isLastIntakeInBand(lastTakenAt, hit.band, nowBerlin, tz, earlyFloorMins)
) {
return best;
}
- if (!best.status || STATUS_PRIORITY[hit.status] > STATUS_PRIORITY[best.status]) {
+ if (
+ !best.status ||
+ STATUS_PRIORITY[hit.status] > STATUS_PRIORITY[best.status]
+ ) {
+ // v1.16.9 — day-scale early-take downgrade: a weekly injectable
+ // taken days before its slot day is already on board, so the pill
+ // must carry last-dose context instead of prompting a full take
+ // (a "Jetzt einnehmen" / overdue prompt here is a double-dose
+ // prompt). The server next-due stays canonical — only the pill's
+ // framing changes; the day count rides along for the copy.
+ const cadence = dayScaleCadence(s.daysOfWeek);
+ const takenEarlyDaysAgo = cadence.dayScale
+ ? earlyTakeDaysAgo(lastTakenAt, nowBerlin, tz, cadence.periodDays)
+ : null;
return {
status: hit.status,
schedule: s,
@@ -481,6 +614,7 @@ export function reduceCurrentWindowStatus(
start: hit.band.startHm,
end: hit.band.endHm,
},
+ takenEarlyDaysAgo,
};
}
return best;
diff --git a/src/lib/openapi/routes/insights.ts b/src/lib/openapi/routes/insights.ts
index 83d68356d..edc57407a 100644
--- a/src/lib/openapi/routes/insights.ts
+++ b/src/lib/openapi/routes/insights.ts
@@ -606,6 +606,35 @@ const dashboardSnapshotResponse = z
glucoseByContext: dataSummaryRecord,
})
.nullable(),
+ // Dashboard hero — today's medication block (fast phase, always
+ // present). Projection-backed tally + earliest next-due across
+ // active medications.
+ medsToday: z
+ .object({
+ activeCount: z.number().int(),
+ scheduledToday: z.number().int(),
+ takenToday: z.number().int(),
+ skippedToday: z.number().int(),
+ nextDueAt: z.string().nullable(),
+ nextDueOverdue: z.boolean(),
+ nextDueMedicationName: z.string().nullable(),
+ })
+ .describe(
+ "Today's medication block: active-medication count, today-window tally (scheduled / taken / skipped), and the earliest next-due slot across active medications. `nextDueOverdue: true` marks an OPEN overdue slot (anchor passed, still inside its catch-up band). Staleness contract: the snapshot is cache-served, so a `nextDueAt` in the past with `nextDueOverdue: false` means the anchor passed after the snapshot was built — render the plain day summary, never an overdue state.",
+ ),
+ // Dashboard hero — health score (warm phase, nullable on a
+ // rollup-coverage miss). Score + band + delta only; the per-pillar
+ // component breakdown stays on the analytics route.
+ healthScore: z
+ .object({
+ score: z.number().int(),
+ band: z.enum(["green", "yellow", "red"]),
+ delta: z.number().nullable(),
+ })
+ .nullable()
+ .describe(
+ "Personal health score summary (0..100 score, traffic-light band, week-over-week delta). Null on a rollup-coverage miss (it rides the thick phase alongside `extras`) and when no pillar is computable. Component breakdown is deliberately not serialised here.",
+ ),
briefing: z.record(z.string(), z.unknown()).nullable(),
briefingState: z.enum(["ready", "preparing", "disabled", "no-provider"]),
briefingUpdatedAt: z.string().nullable(),
diff --git a/src/lib/openapi/routes/medications.ts b/src/lib/openapi/routes/medications.ts
index fbbde4171..2bec317a1 100644
--- a/src/lib/openapi/routes/medications.ts
+++ b/src/lib/openapi/routes/medications.ts
@@ -217,7 +217,7 @@ const medicationListEntry = medicationResource
.int()
.nonnegative()
.describe(
- "Number of intake events scheduled for today (user-local day window).",
+ "Number of ACTIONED intake events for today (user-local day window): rows with a recorded `takenAt` or an explicit skip. Pending projector-minted rows do not count — the card overdue-pill suppression compares this against the passed-dose count, and a pending mint must not read as covered.",
),
})
.meta({
@@ -619,7 +619,7 @@ export const medicationPaths: NonNullable = {
tags: ["Medications"],
summary: "List medications for the calling user",
description:
- "Returns every medication owned by the caller (active + paused), ordered by `createdAt DESC`. Each row carries its nested `schedules`, the joined clinical `category`, the latest non-skipped `lastTakenAt`, and the count of intake events scheduled for today (`todayEventCount`). The response is cached server-side for 60 s per user; writes flush the cache.",
+ "Returns every medication owned by the caller (active + paused), ordered by `createdAt DESC`. Each row carries its nested `schedules`, the joined clinical `category`, the latest non-skipped `lastTakenAt`, and the count of today's actioned intake events (`todayEventCount`). The response is cached server-side for 60 s per user; writes flush the cache.",
responses: {
"200": {
description: "Medication list.",
diff --git a/src/lib/validations/__tests__/medication-intake-event.test.ts b/src/lib/validations/__tests__/medication-intake-event.test.ts
index 402fe7110..25930c729 100644
--- a/src/lib/validations/__tests__/medication-intake-event.test.ts
+++ b/src/lib/validations/__tests__/medication-intake-event.test.ts
@@ -11,7 +11,11 @@
*/
import { describe, expect, it } from "vitest";
-import { updateIntakeEventSchema } from "@/lib/validations/medication";
+import {
+ externalIntakeSchema,
+ intakeSchema,
+ updateIntakeEventSchema,
+} from "@/lib/validations/medication";
const HOUR_MS = 60 * 60 * 1000;
const YEAR_MS = 365 * 24 * HOUR_MS;
@@ -74,3 +78,70 @@ describe("updateIntakeEventSchema — takenAt bounds (P0-4)", () => {
expect(result.success).toBe(true);
});
});
+
+/**
+ * v1.16.9 — the same bounds on every CREATE path. The retro-add dialog
+ * posts through `intakeSchema`, the iOS sync through the bulk entry
+ * shape, external integrations through `externalIntakeSchema`; none of
+ * them may insert a row the edit path would refuse.
+ */
+describe("intakeSchema — takenAt bounds on create (v1.16.9)", () => {
+ it("rejects a future takenAt beyond the skew allowance", () => {
+ const result = intakeSchema.safeParse({
+ medicationId: "med-1",
+ takenAt: new Date(Date.now() + HOUR_MS).toISOString(),
+ });
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error.issues[0]?.message).toContain("future");
+ }
+ });
+
+ it("rejects a takenAt more than 5 years in the past", () => {
+ const result = intakeSchema.safeParse({
+ medicationId: "med-1",
+ takenAt: new Date(Date.now() - 6 * YEAR_MS).toISOString(),
+ });
+ expect(result.success).toBe(false);
+ if (!result.success) {
+ expect(result.error.issues[0]?.message).toContain("5 years");
+ }
+ });
+
+ it("accepts a recent takenAt and a body that omits it", () => {
+ expect(
+ intakeSchema.safeParse({
+ medicationId: "med-1",
+ takenAt: new Date(Date.now() - 2 * HOUR_MS).toISOString(),
+ }).success,
+ ).toBe(true);
+ expect(intakeSchema.safeParse({ medicationId: "med-1" }).success).toBe(
+ true,
+ );
+ });
+});
+
+describe("externalIntakeSchema — takenAt bounds on ingest (v1.16.9)", () => {
+ it("rejects future and implausibly-old instants, accepts recent ones", () => {
+ const future = externalIntakeSchema.safeParse({
+ medicationName: "Metformin",
+ idempotencyKey: "k-1",
+ takenAt: new Date(Date.now() + HOUR_MS).toISOString(),
+ });
+ expect(future.success).toBe(false);
+
+ const ancient = externalIntakeSchema.safeParse({
+ medicationName: "Metformin",
+ idempotencyKey: "k-2",
+ takenAt: new Date(Date.now() - 6 * YEAR_MS).toISOString(),
+ });
+ expect(ancient.success).toBe(false);
+
+ const ok = externalIntakeSchema.safeParse({
+ medicationName: "Metformin",
+ idempotencyKey: "k-3",
+ takenAt: new Date(Date.now() - HOUR_MS).toISOString(),
+ });
+ expect(ok.success).toBe(true);
+ });
+});
diff --git a/src/lib/validations/medication.ts b/src/lib/validations/medication.ts
index 03bda0bc9..1c9213675 100644
--- a/src/lib/validations/medication.ts
+++ b/src/lib/validations/medication.ts
@@ -163,6 +163,30 @@ function hhmmToMinutes(hhmm: string): number {
return Number(h) * 60 + Number(m);
}
+/**
+ * v1.15.19 introduced `takenAt` plausibility bounds on the EDIT path
+ * (audit P0-4); v1.16.9 lifts them onto every CREATE path too (the
+ * per-medication intake POST, the bulk endpoint, the external ingest) so
+ * the retro-add dialog and a hand-rolled API call can't insert a row a
+ * decade in the past or hours in the future. Future allowance covers
+ * client clock skew; the 5-year floor matches the GLP-1 dose-change
+ * validator's window. Slot-distance / medication-start checks stay in
+ * the routes — the schema cannot see the medication.
+ */
+export const TAKEN_AT_CLOCK_SKEW_MS = 5 * 60 * 1000;
+export const TAKEN_AT_MAX_AGE_MS = 5 * 365 * 24 * 60 * 60 * 1000;
+
+/** ISO `takenAt` → `Date` with the shared plausibility bounds applied. */
+export const boundedTakenAtSchema = z.iso
+ .datetime({ offset: true })
+ .transform((s) => new Date(s))
+ .refine((d) => d.getTime() <= Date.now() + TAKEN_AT_CLOCK_SKEW_MS, {
+ message: "takenAt must not be in the future",
+ })
+ .refine((d) => d.getTime() >= Date.now() - TAKEN_AT_MAX_AGE_MS, {
+ message: "takenAt must be within the last 5 years",
+ });
+
export const scheduleSchema = z
.object({
windowStart: z
@@ -598,12 +622,10 @@ export const intakeSchema = z
.describe(
"Slot the dose belongs to. Defaults to `takenAt` (or `now()` when both are absent) so the compliance pairing logic can pin the dose to a schedule slot.",
),
- takenAt: z.iso
- .datetime({ offset: true })
- .transform((s) => new Date(s))
+ takenAt: boundedTakenAtSchema
.optional()
.describe(
- "When the dose was actually taken. NULL when `skipped` is true; defaults to `now()` for non-skipped intakes.",
+ "When the dose was actually taken. NULL when `skipped` is true; defaults to `now()` for non-skipped intakes. Must not lie in the future (5-minute clock-skew allowance) nor more than 5 years in the past.",
),
skipped: z
.boolean()
@@ -673,10 +695,8 @@ export const intakeSchema = z
export const externalIntakeSchema = z.object({
medicationName: z.string().min(1).max(200),
- takenAt: z.iso
- .datetime({ offset: true })
- .transform((s) => new Date(s))
- .optional(),
+ // v1.16.9 — same plausibility bounds as the interactive create paths.
+ takenAt: boundedTakenAtSchema.optional(),
idempotencyKey: z.string().max(128),
});
@@ -718,22 +738,9 @@ export const listIntakeEventsSchema = z.object({
* checks stay out of the schema — it cannot see the medication — and live
* in the route (start-date guard) + the edit dialog (non-blocking hint).
*/
-const TAKEN_AT_CLOCK_SKEW_MS = 5 * 60 * 1000;
-const TAKEN_AT_MAX_AGE_MS = 5 * 365 * 24 * 60 * 60 * 1000;
-
export const updateIntakeEventSchema = z
.object({
- takenAt: z.iso
- .datetime({ offset: true })
- .transform((s) => new Date(s))
- .refine((d) => d.getTime() <= Date.now() + TAKEN_AT_CLOCK_SKEW_MS, {
- message: "takenAt must not be in the future",
- })
- .refine((d) => d.getTime() >= Date.now() - TAKEN_AT_MAX_AGE_MS, {
- message: "takenAt must be within the last 5 years",
- })
- .nullable()
- .optional(),
+ takenAt: boundedTakenAtSchema.nullable().optional(),
skipped: z.boolean().optional(),
scheduledFor: z.iso
.datetime({ offset: true })
diff --git a/src/lib/validations/whoop.ts b/src/lib/validations/whoop.ts
index ea33fe786..f547569d7 100644
--- a/src/lib/validations/whoop.ts
+++ b/src/lib/validations/whoop.ts
@@ -7,8 +7,10 @@ import { z } from "zod/v4";
* multi-operator product). Stored encrypted on `User`.
*/
export const whoopCredentialsSchema = z.object({
- clientId: z.string().min(1).max(200),
- clientSecret: z.string().min(1).max(200),
+ // Trimmed: a trailing space or newline from the portal's copy button
+ // reaches WHOOP verbatim and answers as "unknown client".
+ clientId: z.string().trim().min(1).max(200),
+ clientSecret: z.string().trim().min(1).max(200),
});
export type WhoopCredentialsInput = z.infer;
diff --git a/src/lib/whoop/client.ts b/src/lib/whoop/client.ts
index 7eb91358e..90cf76fd2 100644
--- a/src/lib/whoop/client.ts
+++ b/src/lib/whoop/client.ts
@@ -34,8 +34,10 @@ export interface WhoopCredentials {
}
function getRedirectUri(): string {
+ // `||`, not `??`: the compose whitelist materialises the var as an empty
+ // string when unset, which must still fall through to the derived URI.
return (
- process.env.WHOOP_REDIRECT_URI ??
+ process.env.WHOOP_REDIRECT_URI ||
`${process.env.NEXT_PUBLIC_APP_URL}/api/whoop/callback`
);
}
diff --git a/tests/integration/medications-intake-bulk.test.ts b/tests/integration/medications-intake-bulk.test.ts
index df18caf3f..2e42a6324 100644
--- a/tests/integration/medications-intake-bulk.test.ts
+++ b/tests/integration/medications-intake-bulk.test.ts
@@ -377,8 +377,11 @@ describe("POST /api/medications/intake/bulk (real Postgres)", () => {
});
const { POST } = await import("@/app/api/medications/intake/bulk/route");
- const t1 = new Date("2026-06-15T09:00:00.000Z");
- const t2 = new Date("2026-06-15T15:00:00.000Z");
+ // Relative past instants: takenAt now carries a no-future plausibility
+ // bound, so fixed calendar dates would rot into rejections.
+ const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
+ const t1 = new Date(yesterday.setUTCHours(9, 0, 0, 0));
+ const t2 = new Date(yesterday.setUTCHours(15, 0, 0, 0));
await POST(
makeRequest({
entries: [
@@ -408,7 +411,14 @@ describe("POST /api/medications/intake/bulk (real Postgres)", () => {
it("creates exactly one row for a fresh scheduled dose with no pre-existing slot row", async () => {
const prisma = getPrismaClient();
const medId = await makeScheduledMed(["19:00"]);
- const slot = localHmAsUtc(new Date(), TZ, 19, 0);
+ // Yesterday's slot: today's 19:00 is in the future for any run before
+ // the evening, and a future takenAt is now rejected by design.
+ const slot = localHmAsUtc(
+ new Date(Date.now() - 24 * 60 * 60 * 1000),
+ TZ,
+ 19,
+ 0,
+ );
const { POST } = await import("@/app/api/medications/intake/bulk/route");
const res = await POST(