From 423c0caca45c861878e49a42be3171e6c8ef49bb Mon Sep 17 00:00:00 2001 From: Jake Date: Sun, 26 Apr 2026 19:45:11 +0100 Subject: [PATCH] =?UTF-8?q?feat(nudges):=20B3.2=20=E2=80=94=20notification?= =?UTF-8?q?s=20digest=20mode?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit settings.nudgeMode (Off / Immediate / Digest) replaces the binary nudgesEnabled toggle in the Settings UI; the field stays in storage mirrored from nudgeMode for back-compat readers. Digest mode queues trigger events (deduped by key) into a localStorage-persisted buffer and delivers them as a single aggregated notification at user-chosen times of day (1–3 slots). Body shows up to 3 lines with a "...and N more" truncation tail and honours nudgesSpeakAloud. Switching from digest to off clears the queue; digest to immediate replays. Co-Authored-By: Claude Opus 4.7 (1M context) --- src/lib/pages/SettingsPage.svelte | 124 +++++++++++- src/lib/stores/nudgeBus.svelte.ts | 308 ++++++++++++++++++++++++++++-- 2 files changed, 414 insertions(+), 18 deletions(-) diff --git a/src/lib/pages/SettingsPage.svelte b/src/lib/pages/SettingsPage.svelte index 97aeb5f..5f23a0d 100644 --- a/src/lib/pages/SettingsPage.svelte +++ b/src/lib/pages/SettingsPage.svelte @@ -24,6 +24,7 @@ // that just mutates the page-local llmLoaded bool. The store // version drives the sidebar chip (brief item #31). import { refreshLlmStatus as refreshGlobalLlmStatus, markError as markGlobalLlmError, markLoading as markGlobalLlmLoading } from "$lib/stores/llmStatus.svelte.js"; + import { handleNudgeModeChange } from "$lib/stores/nudgeBus.svelte.ts"; const prefs = getPreferences(); @@ -841,6 +842,68 @@ } }); + // B3.2 — nudge mode picker. SegmentedButton works on string options; + // settings.nudgeMode is the lowercase enum. Mirror via display labels + // and call the bus' mode-switch hygiene hook on each transition. + const NUDGE_MODE_LABELS = ["Off", "Immediate", "Digest"] as const; + function modeFromLabel(label: string): "off" | "immediate" | "digest" { + if (label === "Immediate") return "immediate"; + if (label === "Digest") return "digest"; + return "off"; + } + function labelFromMode(mode: "off" | "immediate" | "digest"): string { + if (mode === "immediate") return "Immediate"; + if (mode === "digest") return "Digest"; + return "Off"; + } + let nudgeModeLabel = $state(labelFromMode(settings.nudgeMode ?? "off")); + $effect(() => { + const next = modeFromLabel(nudgeModeLabel); + const prev = settings.nudgeMode; + if (prev !== next) { + // Update both fields together: the back-compat boolean stays in + // lockstep so older readers (and the legacy fallback inside + // nudgeBus) see a consistent value. + settings.nudgeMode = next; + settings.nudgesEnabled = next !== "off"; + saveSettings(); + // Run mode-switch hygiene (clear queue / replay queue) only + // when prev was a real value, not the initial undefined that + // can hit during the very first $effect tick. + if (prev === "off" || prev === "immediate" || prev === "digest") { + void handleNudgeModeChange(prev, next); + } + } + }); + $effect(() => { + const label = labelFromMode(settings.nudgeMode ?? "off"); + if (nudgeModeLabel !== label) nudgeModeLabel = label; + }); + + // B3.2 — digest-times editor. The user picks 1-3 HH:MM slots; we + // validate strictly (no "8:00", no "24:00") before writing. + let digestTimeDraft = $state("08:00"); + function isValidHHMM(value: string): boolean { + return /^([01]\d|2[0-3]):([0-5]\d)$/.test(value); + } + function addDigestTime() { + const v = digestTimeDraft; + if (!isValidHHMM(v)) return; + const list = Array.isArray(settings.nudgeDigestTimes) ? [...settings.nudgeDigestTimes] : []; + if (list.length >= 3) return; + if (list.includes(v)) return; + list.push(v); + list.sort(); + settings.nudgeDigestTimes = list; + saveSettings(); + } + function removeDigestTime(t: string) { + const list = Array.isArray(settings.nudgeDigestTimes) ? [...settings.nudgeDigestTimes] : []; + if (list.length <= 1) return; + settings.nudgeDigestTimes = list.filter((x) => x !== t); + saveSettings(); + } + async function downloadModel(size) { downloadingModel = size; downloadProgress = 0; @@ -1732,13 +1795,62 @@ Gentle, anticipatory reminders. Capped at 3 per hour. Never fires while you're looking at Corbie.

- + +
+

Delivery

+ +
+

+ {#if nudgeModeLabel === "Off"} + Nudges are off. Triggers won't fire and nothing is queued. + {:else if nudgeModeLabel === "Immediate"} + Nudges fire when the trigger happens — capped at 3 per hour, never while Corbie has focus. + {:else} + Triggers are batched into a single notification at your chosen time(s) below. + {/if} +

- {#if settings.nudgesEnabled} + {#if nudgeModeLabel === "Digest"} +
+

Digest times

+
+ {#each (settings.nudgeDigestTimes ?? []) as t} + + {t} + + + {/each} +
+
+ + +
+ {#if (settings.nudgeDigestTimes?.length ?? 0) <= 1} +

At least one time required for digest.

+ {/if} + {#if (settings.nudgeDigestTimes?.length ?? 0) >= 3} +

Maximum of three times. Remove one to add another.

+ {/if} +
+ {/if} + + {#if nudgeModeLabel !== "Off"}
| null = null; let triagePollHandle: ReturnType | null = null; +let digestCheckHandle: ReturnType | null = null; // parentTaskId → scheduled timeout handle for "idle since step created". // Cleared when a step or parent task gets marked done in the same session. const microStepTimers = new Map>(); +// --- Mode helpers ---------------------------------------------------- + +// `nudgeMode` is the source of truth; if for any reason it's missing +// (older blob that hasn't passed through loadSettings yet) fall back +// to the legacy boolean. This mirrors the migration in page.svelte.ts. +function getNudgeMode(): "off" | "immediate" | "digest" { + const mode = settings.nudgeMode; + if (mode === "off" || mode === "immediate" || mode === "digest") return mode; + return settings.nudgesEnabled ? "immediate" : "off"; +} + // --- Permission ------------------------------------------------------ async function ensurePermission(): Promise { @@ -93,8 +125,14 @@ function pruneRecentNudges(now: number): void { } function canNudgeNow(now: number): boolean { - if (!settings.nudgesEnabled) return false; + const mode = getNudgeMode(); + // Off path: no nudges, ever (including from a digest replay). + if (mode === "off") return false; + // Mute always wins, even over digest delivery. if (settings.nudgesMuted) return false; + // Digest mode never fires the immediate path; the digest scheduler + // calls deliverDigestPayload() directly which bypasses canNudgeNow. + if (mode === "digest") return false; // B3.1 — fresh-start window stays quiet on every trigger. The window // is the user explicitly being told "this week starts fresh"; an OS // notification an hour later would directly contradict that frame. @@ -105,7 +143,7 @@ function canNudgeNow(now: number): boolean { return true; } -// --- Delivery -------------------------------------------------------- +// --- Delivery (immediate) ------------------------------------------- async function deliver(title: string, body: string): Promise { const now = Date.now(); @@ -132,6 +170,241 @@ async function deliver(title: string, body: string): Promise { } } +// --- Digest queue (B3.2) -------------------------------------------- + +function loadDigestQueue(): DigestQueueItem[] { + if (typeof localStorage === "undefined") return []; + const raw = localStorage.getItem(DIGEST_QUEUE_KEY); + if (!raw) return []; + try { + const parsed = JSON.parse(raw); + if (!Array.isArray(parsed)) return []; + return parsed.filter( + (item): item is DigestQueueItem => + item + && typeof item.key === "string" + && typeof item.title === "string" + && typeof item.body === "string" + && typeof item.queuedAt === "number", + ); + } catch { + return []; + } +} + +function saveDigestQueue(queue: DigestQueueItem[]): void { + if (typeof localStorage === "undefined") return; + try { + if (queue.length === 0) { + localStorage.removeItem(DIGEST_QUEUE_KEY); + } else { + localStorage.setItem(DIGEST_QUEUE_KEY, JSON.stringify(queue)); + } + } catch { + // Storage full / private mode — silently drop. The next trigger + // will try again; we don't want to surface an error here. + } +} + +function pruneDigestQueue(queue: DigestQueueItem[], now: number): DigestQueueItem[] { + return queue.filter((item) => now - item.queuedAt < DAY_MS); +} + +function enqueueDigestItem(key: string, title: string, body: string): void { + const now = Date.now(); + const queue = pruneDigestQueue(loadDigestQueue(), now); + // Dedupe by key: most recent wins (replace the prior entry's text + + // timestamp). Keeps the digest body free of the same trigger fired + // twice between delivery slots. + const filtered = queue.filter((item) => item.key !== key); + filtered.push({ key, title, body, queuedAt: now }); + saveDigestQueue(filtered); +} + +/** + * Trigger entry point. Inspects the current nudge mode and either + * delivers immediately (preserving the existing suppression chain) or + * pushes the item onto the digest queue. Off-mode drops silently. + */ +function enqueueOrDeliver(key: string, title: string, body: string): void { + const mode = getNudgeMode(); + if (mode === "off") return; + if (mode === "digest") { + enqueueDigestItem(key, title, body); + return; + } + void deliver(title, body); +} + +// --- Digest delivery ------------------------------------------------ + +interface LastDeliveryMap { + [slotKey: string]: true; +} + +function loadLastDelivery(): LastDeliveryMap { + if (typeof localStorage === "undefined") return {}; + const raw = localStorage.getItem(DIGEST_LAST_DELIVERY_KEY); + if (!raw) return {}; + try { + const parsed = JSON.parse(raw); + if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) { + return parsed as LastDeliveryMap; + } + return {}; + } catch { + return {}; + } +} + +function saveLastDelivery(map: LastDeliveryMap): void { + if (typeof localStorage === "undefined") return; + try { + localStorage.setItem(DIGEST_LAST_DELIVERY_KEY, JSON.stringify(map)); + } catch { + // Same reasoning as saveDigestQueue. + } +} + +// Drop entries whose date prefix is older than 7 days. Keeps the map +// from growing unbounded across long-running installs. +function pruneLastDelivery(map: LastDeliveryMap, now: number): LastDeliveryMap { + const cutoff = now - 7 * DAY_MS; + const out: LastDeliveryMap = {}; + for (const key of Object.keys(map)) { + // key shape: "YYYY-MM-DD@HH:MM" + const datePart = key.split("@")[0]; + if (!datePart) continue; + const parsed = Date.parse(datePart + "T00:00:00"); + if (Number.isNaN(parsed)) continue; + if (parsed >= cutoff) out[key] = true; + } + return out; +} + +function todayLocalKey(): string { + const d = new Date(); + return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`; +} + +function isValidHHMM(value: string): boolean { + // Strict HH:MM, 24-hour, with leading zeros required. 00:00–23:59. + // Anti-requirement: never accept 24:00 or non-padded forms like "8:00". + const m = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(value); + return m !== null; +} + +function scheduledTimeForToday(hhmm: string, now: Date): Date | null { + if (!isValidHHMM(hhmm)) return null; + const [hh, mm] = hhmm.split(":").map(Number); + return new Date(now.getFullYear(), now.getMonth(), now.getDate(), hh, mm, 0, 0); +} + +function buildDigestBody(items: DigestQueueItem[]): { title: string; body: string } { + const N = items.length; + const title = `Kon — ${N} signal${N === 1 ? "" : "s"}`; + const lines = items.slice(0, 3).map((item) => `• ${item.title}`); + if (N > 3) lines.push(`…and ${N - 3} more.`); + return { title, body: lines.join("\n") }; +} + +async function deliverDigestPayload(items: DigestQueueItem[]): Promise { + if (items.length === 0) return; + // Mute is the only suppression that applies to digest delivery — + // focus and the hourly cap don't apply because the user explicitly + // chose this delivery time. Mode-off is enforced by the caller. + if (settings.nudgesMuted) return; + const ok = await ensurePermission(); + if (!ok) return; + const { title, body } = buildDigestBody(items); + try { + await invoke("deliver_nudge", { input: { title, body } }); + } catch { + // fire-and-forget + } + if (settings.nudgesSpeakAloud) { + try { + await invoke("tts_speak", { + text: body || title, + rate: settings.ttsRate, + voice: settings.ttsVoice ?? null, + }); + } catch { + // fire-and-forget + } + } +} + +async function checkAndDeliverDigests(): Promise { + if (getNudgeMode() !== "digest") return; + const slots = Array.isArray(settings.nudgeDigestTimes) ? settings.nudgeDigestTimes : []; + if (slots.length === 0) return; + const now = new Date(); + const nowMs = now.getTime(); + const dayKey = todayLocalKey(); + let delivery = pruneLastDelivery(loadLastDelivery(), nowMs); + let dirty = false; + for (const slot of slots) { + if (!isValidHHMM(slot)) continue; + const scheduled = scheduledTimeForToday(slot, now); + if (!scheduled) continue; + if (now < scheduled) continue; + const slotKey = `${dayKey}@${slot}`; + if (delivery[slotKey]) continue; + // Refresh the queue inside the loop in case an earlier slot in + // the same tick already consumed it (unlikely with 5-min cadence + // but cheap to be safe). + const queue = pruneDigestQueue(loadDigestQueue(), nowMs); + if (queue.length === 0) { + // Stamp anyway so we don't keep re-checking an empty slot all + // day — the user picked the time, not the content. + delivery[slotKey] = true; + dirty = true; + continue; + } + await deliverDigestPayload(queue); + saveDigestQueue([]); + delivery[slotKey] = true; + dirty = true; + } + if (dirty) saveLastDelivery(delivery); +} + +// --- Mode-switch hygiene (B3.2) ------------------------------------- + +/** + * Called from the Settings UI when the user changes `nudgeMode`. The + * Settings page is responsible for writing both `nudgeMode` and the + * back-compat `nudgesEnabled` boolean; this function only handles the + * queue / replay side-effects. + */ +export async function handleNudgeModeChange( + prev: "off" | "immediate" | "digest", + next: "off" | "immediate" | "digest", +): Promise { + if (prev === next) return; + if (prev === "digest" && next === "off") { + // Bin the queue — the user explicitly turned nudges off. Anything + // still in there would be a surprise next time digest is re-enabled. + saveDigestQueue([]); + return; + } + if (prev === "digest" && next === "immediate") { + // Replay each queued item through the immediate path. Each call + // re-checks the suppression chain (focus, hourly cap, fresh-start), + // so a flood of replays still respects the cap. + const queue = pruneDigestQueue(loadDigestQueue(), Date.now()); + saveDigestQueue([]); + for (const item of queue) { + // eslint-disable-next-line no-await-in-loop + await deliver(item.title, item.body); + } + return; + } + // immediate→digest, off→*, immediate→off: nothing to clean up here. + // (off→immediate / off→digest don't have a queue worth replaying.) +} + // --- Trigger: inactivity with active timer --------------------------- function onTimerStart(event: Event) { @@ -164,7 +437,8 @@ function checkInactivityWithActiveTimer(now: number) { if (blurredAt === null) return; if (now - blurredAt < INACTIVITY_TIMER_THRESHOLD_MS) return; timerNudgeFiredThisSession = true; - void deliver( + enqueueOrDeliver( + "timer-inactivity", "Timer's still running.", "It's been ticking while you've been away. Pick up where you left off, or stop it.", ); @@ -172,11 +446,6 @@ function checkInactivityWithActiveTimer(now: number) { // --- Trigger: pending morning triage --------------------------------- -function todayLocalKey(): string { - const d = new Date(); - return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`; -} - let triageNudgeFiredOnKey: string | null = null; async function checkPendingMorningTriage() { @@ -194,7 +463,8 @@ async function checkPendingMorningTriage() { } if (lastShown === today) return; triageNudgeFiredOnKey = today; - void deliver( + enqueueOrDeliver( + "morning-triage", "A few things waiting", "When you're ready, Corbie has your morning list. No rush.", ); @@ -209,7 +479,8 @@ function onMicroStepGenerated(event: Event) { clearMicroStepTimer(parentTaskId); const handle = setTimeout(() => { microStepTimers.delete(parentTaskId); - void deliver( + enqueueOrDeliver( + `microstep-idle:${parentTaskId}`, "Still with that one?", "Your breakdown is here when you want to pick the first step.", ); @@ -264,6 +535,15 @@ export function startNudgeBus(): void { triagePollHandle = setInterval(() => { void checkPendingMorningTriage(); }, MORNING_TRIAGE_CHECK_INTERVAL_MS); + + // B3.2 — digest scheduling. Prune stale items at boot, then check + // immediately and on a 5-min cadence. The check is a no-op outside + // digest mode, so leaving the interval running is cheap. + saveDigestQueue(pruneDigestQueue(loadDigestQueue(), Date.now())); + void checkAndDeliverDigests(); + digestCheckHandle = setInterval(() => { + void checkAndDeliverDigests(); + }, DIGEST_CHECK_INTERVAL_MS); } export function stopNudgeBus(): void { @@ -287,6 +567,10 @@ export function stopNudgeBus(): void { clearInterval(triagePollHandle); triagePollHandle = null; } + if (digestCheckHandle !== null) { + clearInterval(digestCheckHandle); + digestCheckHandle = null; + } for (const handle of microStepTimers.values()) clearTimeout(handle); microStepTimers.clear();