Phase 2: learning engine — history, SRS review, mistakes, stats, exam, reminders

Answer history and schedules
- Every answer is recorded (deck, activity, topic, correct/wrong, time)
  in a versioned IndexedDB log (freezmo-learning v1, stores answers +
  srs), mirrored in memory for synchronous React reads and capped at
  20k answers (oldest pruned). StudyFeed records as it grades.
- Light SM-2 schedule per activity: 1 day, 3 days, then interval x
  ease; wrong answers return in ten minutes with the ease nudged down.

Review, mistakes, stats
- Library 'Smart review' card: due count, mistakes count (latest
  answer wrong — clears itself when answered correctly), today's goal
  progress. Review sessions freeze their item list at start.
- New /review (due across decks, ?mistakes=1 global or ?deck= per
  deck) built on a shared SessionFeed with the study feed's snap/keyboard
  mechanics, wake lock and a results slide.
- New /stats: day streak, five-week calendar, accuracy per subject and
  per deck, weakest topics (>=3 answers), daily-goal progress.
- Daily goal configurable in Settings (10/20/30/50).

Exam mode
- New /exam: pick decks, question count, optional timer; no hints
  (a NoHints context hides hint rows and the self-check escape);
  results with score, per-deck and per-topic breakdown; wrong answers
  land in the mistakes set through the normal history.

Reminders (conditional)
- VAPID-gated: GET/POST/DELETE /api/push and POST /api/push/test with
  the standard route pattern, RATE_LIMIT_PUSH, zod, auth before body.
  Subscriptions stored server-side as endpoint + keys only (PUSH_DIR).
  UI hidden entirely without keys; iOS install note; service worker
  push/notificationclick handlers; scripts/send-reminders.mjs for a
  cron/systemd timer; web-push added as the one server dependency.

Verified: new phase-2 suite 42/42 (history/SRS shapes from a real study
run, mistakes clearing, review session, stats math, exam timer and
breakdowns, VAPID-less hidden state plus the configured
subscribe/validate/test/delete path against a second instance) plus
regression 74/74, mobile 52/52, wizard 80/80, declutter 116/116,
animation 8/8, native 35/35, phase1 38/38, i18n 25/25. Key parity
709/709. Lint + build clean. SW freezmo-v26.

lib/push-store.ts

@@ -0,0 +1,64 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+/**
+ * Server-side push subscriptions: one JSON file with endpoint + keys and a
+ * creation timestamp. No personal data, no history, no user ids — and the
+ * whole feature stays hidden unless VAPID keys are configured.
+ */
+
+export type PushSubscriptionRecord = {
+  endpoint: string;
+  keys: { p256dh: string; auth: string };
+  createdAt: number;
+};
+
+function fileFor(dir: string): string {
+  return path.join(dir, "subscriptions.json");
+}
+
+export async function readSubscriptions(dir: string): Promise<PushSubscriptionRecord[]> {
+  try {
+    const raw = await fs.readFile(fileFor(dir), "utf8");
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (entry): entry is PushSubscriptionRecord =>
+        Boolean(entry) &&
+        typeof (entry as PushSubscriptionRecord).endpoint === "string" &&
+        typeof (entry as PushSubscriptionRecord).keys?.p256dh === "string" &&
+        typeof (entry as PushSubscriptionRecord).keys?.auth === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+async function writeSubscriptions(dir: string, next: PushSubscriptionRecord[]): Promise<void> {
+  await fs.mkdir(dir, { recursive: true });
+  const file = fileFor(dir);
+  const temporary = `${file}.${crypto.randomUUID()}.tmp`;
+  await fs.writeFile(temporary, JSON.stringify(next, null, 2), "utf8");
+  await fs.rename(temporary, file);
+}
+
+/** Adds or refreshes a subscription (deduped by endpoint). */
+export async function addSubscription(
+  dir: string,
+  subscription: { endpoint: string; keys: { p256dh: string; auth: string } },
+): Promise<number> {
+  const current = await readSubscriptions(dir);
+  const next = current.filter((entry) => entry.endpoint !== subscription.endpoint);
+  next.push({ ...subscription, createdAt: Date.now() });
+  // A cap keeps a runaway script from filling the disk.
+  const capped = next.slice(-2000);
+  await writeSubscriptions(dir, capped);
+  return capped.length;
+}
+
+export async function removeSubscription(dir: string, endpoint: string): Promise<number> {
+  const current = await readSubscriptions(dir);
+  const next = current.filter((entry) => entry.endpoint !== endpoint);
+  await writeSubscriptions(dir, next);
+  return next.length;
+}