M6 1908b: foreground reminder delivery + recurrence/snooze UI (frontend)

Completes 1908 without Web Push. While the app is open, due reminders now
actually surface; recurring reminders + snooze/done are manageable.

- reminders store (singleton): polls /api/notes/reminders every 45s while
  the app is open; each due reminder fires ONCE as a toast (with an "Open"
  action) and, if the user opts in, a page-context OS Notification — no
  service worker, no PWA. Silently primes a stale backlog on first load;
  only announces recently-due ones. AppShell starts/stops it.
- Editor reminder section: a Repeat picker (Does not repeat / Daily /
  Weekly / Monthly / Yearly) + Done (advances a recurring reminder / clears
  a one-off) + Snooze 1h/1d, shown when a reminder is set.
- RemindersView rebuilt as a chronological list: per row a due time +
  recurrence badge + Done / 1h / 1d, click to open; plus an "Enable
  notifications" opt-in and a note that background alerts come with native.
- Note type gains `recurrence`; notes store setRecurrence /
  completeReminder / snoozeReminder.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FRgehjoz7Yv8LkUfADxACm

frontend/src/stores/notes.ts

@@ -77,6 +77,7 @@ export interface Note {
   archived: boolean;
   trashed: boolean;
   remind_at: string | null;
+  recurrence: string | null;
   labels: NoteLabel[];
   items: ChecklistItem[];
   attachments: Attachment[];
@@ -159,7 +160,9 @@ export const useNotesStore = defineStore("notes", () => {
 
   async function mutate(
     id: string,
-    changes: Partial<Pick<Note, "title" | "body" | "color" | "kind" | "pinned" | "archived" | "remind_at">>,
+    changes: Partial<
+      Pick<Note, "title" | "body" | "color" | "kind" | "pinned" | "archived" | "remind_at" | "recurrence">
+    >,
   ): Promise<void> {
     reconcile(await api.patch<Note>(`/api/notes/${id}`, changes));
   }
@@ -173,8 +176,16 @@ export const useNotesStore = defineStore("notes", () => {
   const setColor = (id: string, color: NoteColor) => mutate(id, { color });
   const setKind = (id: string, kind: NoteKind) => mutate(id, { kind });
   const setReminder = (id: string, remindAt: string | null) => mutate(id, { remind_at: remindAt });
+  const setRecurrence = (id: string, recurrence: string | null) => mutate(id, { recurrence });
   const saveEdit = (id: string, changes: { title: string; body: string; color: NoteColor }) => mutate(id, changes);
 
+  async function completeReminder(id: string): Promise<void> {
+    reconcile(await api.post<Note>(`/api/notes/${id}/reminder/complete`));
+  }
+  async function snoozeReminder(id: string, minutes: number): Promise<void> {
+    reconcile(await api.post<Note>(`/api/notes/${id}/reminder/snooze`, { minutes }));
+  }
+
   async function setLabels(id: string, labelIds: string[]): Promise<void> {
     reconcile(await api.put<Note>(`/api/notes/${id}/labels`, { label_ids: labelIds }));
   }
@@ -300,6 +311,9 @@ export const useNotesStore = defineStore("notes", () => {
     setColor,
     setKind,
     setReminder,
+    setRecurrence,
+    completeReminder,
+    snoozeReminder,
     saveEdit,
     setLabels,
     addItem,

frontend/src/stores/reminders.ts

@@ -0,0 +1,70 @@
+import { defineStore } from "pinia";
+import { ref } from "vue";
+import { api } from "../api/client";
+import router from "../router";
+import { useUiStore } from "./ui";
+import type { Note } from "./notes";
+
+// Foreground reminder delivery — NO Web Push / service worker (per operator). While
+// the app is open, poll for due reminders and surface each once as a toast (and, if
+// the user opted in, a page-context OS notification). Real background delivery is a
+// native-client concern.
+const POLL_MS = 45_000;
+const RECENT_MS = 15 * 60 * 1000; // on first load, only announce reminders due this recently
+
+export const useReminderStore = defineStore("reminders", () => {
+  const osSupported = typeof Notification !== "undefined";
+  const osEnabled = ref(osSupported && Notification.permission === "granted");
+  // note id → the remind_at we already fired, so each occurrence notifies at most once.
+  const notified = new Map<string, string>();
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let primed = false;
+
+  async function check(): Promise<void> {
+    const ui = useUiStore();
+    let notes: Note[];
+    try {
+      notes = (await api.get<{ notes: Note[] }>("/api/notes/reminders")).notes;
+    } catch {
+      return;
+    }
+    const now = Date.now();
+    for (const n of notes) {
+      if (!n.remind_at) continue;
+      const due = Date.parse(n.remind_at);
+      if (due > now || notified.get(n.id) === n.remind_at) continue;
+      notified.set(n.id, n.remind_at);
+      // Silently prime a stale backlog on first load; only announce recently-due ones.
+      if (!primed && now - due > RECENT_MS) continue;
+      const title = n.display_title || "Reminder";
+      ui.showToast(`⏰ ${title}`, {
+        label: "Open",
+        run: () => void router.push({ path: "/", query: { open: n.id } }),
+      });
+      if (osEnabled.value) {
+        try {
+          new Notification("ThoughtSync reminder", { body: title });
+        } catch {
+          /* notifications unavailable — the toast still fired */
+        }
+      }
+    }
+    primed = true;
+  }
+
+  function start(): void {
+    if (timer) return;
+    void check();
+    timer = setInterval(() => void check(), POLL_MS);
+  }
+  function stop(): void {
+    if (timer) clearInterval(timer);
+    timer = undefined;
+  }
+  async function enableOs(): Promise<void> {
+    if (!osSupported) return;
+    osEnabled.value = (await Notification.requestPermission()) === "granted";
+  }
+
+  return { osSupported, osEnabled, start, stop, enableOs };
+});