fix: require server env vars

oxfmt was reformatting generated drizzle migration snapshots and
crashing on .ona/review/comments.json. Also runs the formatter
across the full codebase.

Co-authored-by: Ona <no-reply@ona.com>

.github/workflows/build-waitlist-website.yml

@@ -11,7 +11,7 @@ on:
 
 env:
   REGISTRY: cr.nym.sh
-  IMAGE_NAME: aelis-waitlist-website
+  IMAGE_NAME: freya-waitlist-website
 
 jobs:
   build:

.ona/automations.yaml

@@ -1,45 +0,0 @@
-services:
-  expo:
-    name: Expo Dev Server
-    description: Expo development server for aelis-client
-    triggeredBy:
-      - postDevcontainerStart
-    commands:
-      start: cd apps/aelis-client && ./scripts/run-dev-server.sh
-
-  drizzle-studio:
-    name: Drizzle Studio
-    description: Drizzle Studio database browser for aelis-backend
-    triggeredBy:
-      - manual
-    commands:
-      start: |
-        FORWARD_URL=$(gitpod environment port open 4983 --name drizzle-studio-server | sed 's|https://||')
-        echo "Drizzle Studio: https://local.drizzle.studio/?host=${FORWARD_URL}&port=443"
-        cd apps/aelis-backend && bunx drizzle-kit studio --host 0.0.0.0 --port 4983
-
-  aelis-backend:
-    name: Aelis Backend
-    description: Hono API server for aelis-backend (port 3000)
-    triggeredBy:
-      - manual
-    commands:
-      start: |
-        gitpod --context environment environment port open 3000 --name "Aelis Backend" --protocol http
-        TS_IP=$(tailscale ip -4)
-        echo ""
-        echo "------------------ Bun Debugger ------------------"
-        echo "https://debug.bun.sh/#${TS_IP}:6499"
-        echo "------------------ Bun Debugger ------------------"
-        echo ""
-        cd apps/aelis-backend && bun run dev
-
-  admin-dashboard:
-    name: Admin Dashboard
-    description: Vite dev server for admin-dashboard (port 5174)
-    triggeredBy:
-      - manual
-    commands:
-      start: |
-        gitpod --context environment environment port open 5174 --name "Admin Dashboard" --protocol http
-        cd apps/admin-dashboard && bun run dev --host

.oxfmtrc.json

@@ -8,5 +8,5 @@
 		"ignoreCase": true,
 		"newlinesBetween": true
 	},
-	"ignorePatterns": [".claude", "fixtures"]
+	"ignorePatterns": [".claude", ".ona", "drizzle", "fixtures"]
 }

AGENTS.md

@@ -2,7 +2,7 @@
 
 ## Project
 
-AELIS is an AI-powered personal assistant that aggregates data from various sources into a contextual feed. Monorepo with `packages/` (shared libraries) and `apps/` (applications).
+FREYA is an AI-powered personal assistant that aggregates data from various sources into a contextual feed. Monorepo with `packages/` (shared libraries) and `apps/` (applications).
 
 ## Commands
 

README.md

@@ -1,4 +1,4 @@
-# aelis
+# freya
 
 To install dependencies:
 
@@ -8,14 +8,14 @@ bun install
 
 ## Packages
 
-### @aelis/source-tfl
+### @freya/source-tfl
 
 TfL (Transport for London) feed source for tube, overground, and Elizabeth line alerts.
 
 #### Testing
 
 ```bash
-cd packages/aelis-source-tfl
+cd packages/freya-source-tfl
 bun run test
 ```
 

apps/admin-dashboard/src/components/login-page.tsx

@@ -71,7 +71,7 @@ export function LoginPage({ onLogin }: LoginPageProps) {
 								type="email"
 								value={email}
 								onChange={(e) => setEmail(e.target.value)}
-								placeholder="admin@aelis.local"
+								placeholder="admin@freya.local"
 								required
 							/>
 						</div>

apps/admin-dashboard/src/components/reminder-crud-panel.tsx

@@ -0,0 +1,639 @@
+import type { Dispatch, FormEvent, SetStateAction } from "react"
+
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { Check, Loader2, Pencil, Plus, RefreshCw, RotateCcw, Save, Trash2, X } from "lucide-react"
+import { useMemo, useState } from "react"
+import { toast } from "sonner"
+
+import type { FeedItem } from "@/lib/api"
+
+import { Badge } from "@/components/ui/badge"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import { Input } from "@/components/ui/input"
+import { Label } from "@/components/ui/label"
+import {
+	Select,
+	SelectContent,
+	SelectItem,
+	SelectTrigger,
+	SelectValue,
+} from "@/components/ui/select"
+import { Switch } from "@/components/ui/switch"
+import { executeSourceAction, fetchFeed } from "@/lib/api"
+
+const REMINDER_SOURCE_ID = "freya.reminders"
+
+type ReminderPriority = "low" | "normal" | "high"
+type ReminderFrequency = "daily" | "weekly" | "monthly" | "yearly"
+type ReminderEditScope = "this-occurrence" | "this-and-future" | "entire-series"
+
+interface ReminderRecurrence {
+	frequency: ReminderFrequency
+	interval: number
+	count?: number
+	until?: string
+}
+
+interface ReminderFeedData extends Record<string, unknown> {
+	reminderId: string
+	occurrenceId: string
+	title: string
+	notes: string | null
+	originalDueAt: string
+	dueAt: string
+	timeZone: string
+	recurrence: ReminderRecurrence | null
+	priority: ReminderPriority
+	completedAt: string | null
+}
+
+interface ReminderFormState {
+	title: string
+	notes: string
+	dueAt: string
+	priority: ReminderPriority
+	scope: ReminderEditScope
+	recurs: boolean
+	frequency: ReminderFrequency
+	interval: string
+	count: string
+	until: string
+}
+
+const emptyForm: ReminderFormState = {
+	title: "",
+	notes: "",
+	dueAt: toLocalInput(new Date()),
+	priority: "normal",
+	scope: "entire-series",
+	recurs: false,
+	frequency: "daily",
+	interval: "1",
+	count: "",
+	until: "",
+}
+
+export function ReminderCrudPanel() {
+	const queryClient = useQueryClient()
+	const [form, setForm] = useState<ReminderFormState>(emptyForm)
+	const [editing, setEditing] = useState<ReminderFeedData | null>(null)
+	const [deleteScopes, setDeleteScopes] = useState<Record<string, ReminderEditScope>>({})
+
+	const {
+		data: feed,
+		isFetching,
+		refetch,
+	} = useQuery({
+		queryKey: ["feed"],
+		queryFn: fetchFeed,
+	})
+
+	const reminders = useMemo(
+		() => (feed?.items ?? []).filter(isReminderItem).map((item) => item.data),
+		[feed],
+	)
+
+	const actionMutation = useMutation({
+		mutationFn: (input: { actionId: string; params: unknown }) =>
+			executeSourceAction(REMINDER_SOURCE_ID, input.actionId, input.params),
+	})
+
+	const busy = actionMutation.isPending
+	const canConfigureRecurrence = !editing || form.scope !== "this-occurrence"
+
+	async function runAction(actionId: string, params: unknown, success: string): Promise<boolean> {
+		try {
+			await actionMutation.mutateAsync({ actionId, params })
+			await queryClient.invalidateQueries({ queryKey: ["feed"] })
+			toast.success(success)
+			return true
+		} catch (err) {
+			toast.error(err instanceof Error ? err.message : String(err))
+			return false
+		}
+	}
+
+	async function handleSubmit(event: FormEvent<HTMLFormElement>) {
+		event.preventDefault()
+
+		if (editing) {
+			const patch = formToPatch(formFromReminder(editing), form)
+			if (Object.keys(patch).length === 0) {
+				toast.info("No changes to save")
+				return
+			}
+
+			const saved = await runAction(
+				"update-reminder",
+				{
+					reminderId: editing.reminderId,
+					scope: form.scope,
+					occurrenceDueAt: editing.originalDueAt,
+					patch,
+				},
+				"Reminder updated",
+			)
+			if (saved) resetForm()
+			return
+		} else {
+			const created = await runAction(
+				"create-reminder",
+				formToCreatePayload(form),
+				"Reminder created",
+			)
+			if (created) resetForm()
+		}
+	}
+
+	function startEdit(reminder: ReminderFeedData) {
+		setEditing(reminder)
+		setForm(formFromReminder(reminder))
+	}
+
+	function resetForm() {
+		setEditing(null)
+		setForm({ ...emptyForm, dueAt: toLocalInput(new Date()) })
+	}
+
+	function getDeleteScope(reminder: ReminderFeedData): ReminderEditScope {
+		return (
+			deleteScopes[reminderKey(reminder)] ??
+			(reminder.recurrence ? "this-occurrence" : "entire-series")
+		)
+	}
+
+	function setDeleteScope(reminder: ReminderFeedData, scope: ReminderEditScope) {
+		setDeleteScopes((prev) => ({ ...prev, [reminderKey(reminder)]: scope }))
+	}
+
+	return (
+		<Card className="-mx-4">
+			<CardHeader className="pb-4">
+				<div className="flex items-center justify-between gap-3">
+					<CardTitle className="text-sm">Reminders</CardTitle>
+					<Button size="sm" variant="outline" onClick={() => refetch()} disabled={isFetching}>
+						{isFetching ? (
+							<Loader2 className="size-3.5 animate-spin" />
+						) : (
+							<RefreshCw className="size-3.5" />
+						)}
+						Refresh
+					</Button>
+				</div>
+			</CardHeader>
+			<CardContent className="space-y-5">
+				<form className="grid gap-4" onSubmit={handleSubmit}>
+					<div className="grid gap-3 sm:grid-cols-2">
+						<div className="space-y-2 sm:col-span-2">
+							<Label htmlFor="reminder-title" className="text-xs font-medium">
+								Title
+							</Label>
+							<Input
+								id="reminder-title"
+								value={form.title}
+								onChange={(event) => setFormField(setForm, "title", event.target.value)}
+								disabled={busy}
+								required
+							/>
+						</div>
+
+						<div className="space-y-2 sm:col-span-2">
+							<Label htmlFor="reminder-notes" className="text-xs font-medium">
+								Notes
+							</Label>
+							<Input
+								id="reminder-notes"
+								value={form.notes}
+								onChange={(event) => setFormField(setForm, "notes", event.target.value)}
+								disabled={busy}
+							/>
+						</div>
+
+						<div className="space-y-2">
+							<Label htmlFor="reminder-due-at" className="text-xs font-medium">
+								Due
+							</Label>
+							<Input
+								id="reminder-due-at"
+								type="datetime-local"
+								value={form.dueAt}
+								onChange={(event) => setFormField(setForm, "dueAt", event.target.value)}
+								disabled={busy}
+								required
+							/>
+						</div>
+
+						<div className="space-y-2">
+							<Label htmlFor="reminder-priority" className="text-xs font-medium">
+								Priority
+							</Label>
+							<Select
+								value={form.priority}
+								onValueChange={(value) =>
+									setFormField(setForm, "priority", value as ReminderPriority)
+								}
+								disabled={busy}
+							>
+								<SelectTrigger id="reminder-priority">
+									<SelectValue />
+								</SelectTrigger>
+								<SelectContent>
+									<SelectItem value="low">Low</SelectItem>
+									<SelectItem value="normal">Normal</SelectItem>
+									<SelectItem value="high">High</SelectItem>
+								</SelectContent>
+							</Select>
+						</div>
+
+						{editing?.recurrence && (
+							<div className="space-y-2 sm:col-span-2">
+								<Label htmlFor="reminder-edit-scope" className="text-xs font-medium">
+									Edit scope
+								</Label>
+								<Select
+									value={form.scope}
+									onValueChange={(value) =>
+										setFormField(setForm, "scope", value as ReminderEditScope)
+									}
+									disabled={busy}
+								>
+									<SelectTrigger id="reminder-edit-scope">
+										<SelectValue />
+									</SelectTrigger>
+									<SelectContent>
+										<SelectItem value="this-occurrence">This occurrence</SelectItem>
+										<SelectItem value="this-and-future">This and future</SelectItem>
+										<SelectItem value="entire-series">Entire series</SelectItem>
+									</SelectContent>
+								</Select>
+							</div>
+						)}
+					</div>
+
+					{canConfigureRecurrence && (
+						<div className="grid gap-3 rounded-md border p-3 sm:grid-cols-4">
+							<div className="flex items-center justify-between gap-3 sm:col-span-4">
+								<Label htmlFor="reminder-recurs" className="text-xs font-medium">
+									Recurring
+								</Label>
+								<Switch
+									id="reminder-recurs"
+									checked={form.recurs}
+									onCheckedChange={(checked) => setFormField(setForm, "recurs", checked)}
+									disabled={busy}
+								/>
+							</div>
+
+							{form.recurs && (
+								<>
+									<div className="space-y-2 sm:col-span-2">
+										<Label htmlFor="reminder-frequency" className="text-xs font-medium">
+											Frequency
+										</Label>
+										<Select
+											value={form.frequency}
+											onValueChange={(value) =>
+												setFormField(setForm, "frequency", value as ReminderFrequency)
+											}
+											disabled={busy}
+										>
+											<SelectTrigger id="reminder-frequency">
+												<SelectValue />
+											</SelectTrigger>
+											<SelectContent>
+												<SelectItem value="daily">Daily</SelectItem>
+												<SelectItem value="weekly">Weekly</SelectItem>
+												<SelectItem value="monthly">Monthly</SelectItem>
+												<SelectItem value="yearly">Yearly</SelectItem>
+											</SelectContent>
+										</Select>
+									</div>
+
+									<div className="space-y-2">
+										<Label htmlFor="reminder-interval" className="text-xs font-medium">
+											Interval
+										</Label>
+										<Input
+											id="reminder-interval"
+											type="number"
+											min={1}
+											value={form.interval}
+											onChange={(event) => setFormField(setForm, "interval", event.target.value)}
+											disabled={busy}
+										/>
+									</div>
+
+									<div className="space-y-2">
+										<Label htmlFor="reminder-count" className="text-xs font-medium">
+											Count
+										</Label>
+										<Input
+											id="reminder-count"
+											type="number"
+											min={1}
+											value={form.count}
+											onChange={(event) => setFormField(setForm, "count", event.target.value)}
+											disabled={busy}
+										/>
+									</div>
+
+									<div className="space-y-2 sm:col-span-4">
+										<Label htmlFor="reminder-until" className="text-xs font-medium">
+											Until
+										</Label>
+										<Input
+											id="reminder-until"
+											type="datetime-local"
+											value={form.until}
+											onChange={(event) => setFormField(setForm, "until", event.target.value)}
+											disabled={busy}
+										/>
+									</div>
+								</>
+							)}
+						</div>
+					)}
+
+					<div className="flex justify-end gap-2">
+						{editing && (
+							<Button type="button" variant="outline" onClick={resetForm} disabled={busy}>
+								<X className="size-3.5" />
+								Cancel
+							</Button>
+						)}
+						<Button type="submit" disabled={busy || !form.title || !form.dueAt}>
+							{busy ? <Loader2 className="size-3.5 animate-spin" /> : <Save className="size-3.5" />}
+							{editing ? "Update" : "Create"}
+						</Button>
+					</div>
+				</form>
+
+				<div className="space-y-2">
+					<div className="flex items-center justify-between text-xs text-muted-foreground">
+						<span>
+							{reminders.length} {reminders.length === 1 ? "occurrence" : "occurrences"}
+						</span>
+						{!editing && (
+							<Button size="sm" variant="ghost" onClick={resetForm} disabled={busy}>
+								<Plus className="size-3.5" />
+								New
+							</Button>
+						)}
+					</div>
+
+					{reminders.length === 0 && (
+						<div className="rounded-md border border-dashed px-3 py-6 text-center text-sm text-muted-foreground">
+							No reminders in the current feed.
+						</div>
+					)}
+
+					{reminders.map((reminder) => {
+						const deleteScope = getDeleteScope(reminder)
+						return (
+							<ReminderRow
+								key={reminderKey(reminder)}
+								reminder={reminder}
+								busy={busy}
+								deleteScope={deleteScope}
+								onDeleteScopeChange={(scope) => setDeleteScope(reminder, scope)}
+								onEdit={() => startEdit(reminder)}
+								onComplete={() =>
+									runAction(
+										reminder.completedAt ? "uncomplete-reminder" : "complete-reminder",
+										{
+											reminderId: reminder.reminderId,
+											occurrenceDueAt: reminder.originalDueAt,
+										},
+										reminder.completedAt ? "Reminder reopened" : "Reminder completed",
+									)
+								}
+								onDelete={() => {
+									if (
+										!confirm(
+											`Delete ${formatScope(deleteScope).toLowerCase()} for "${reminder.title}"?`,
+										)
+									) {
+										return
+									}
+									void runAction(
+										"delete-reminder",
+										{
+											reminderId: reminder.reminderId,
+											scope: deleteScope,
+											occurrenceDueAt: reminder.originalDueAt,
+										},
+										"Reminder deleted",
+									).then((deleted) => {
+										if (deleted && editing?.reminderId === reminder.reminderId) resetForm()
+									})
+								}}
+							/>
+						)
+					})}
+				</div>
+			</CardContent>
+		</Card>
+	)
+}
+
+function ReminderRow({
+	reminder,
+	busy,
+	deleteScope,
+	onDeleteScopeChange,
+	onEdit,
+	onComplete,
+	onDelete,
+}: {
+	reminder: ReminderFeedData
+	busy: boolean
+	deleteScope: ReminderEditScope
+	onDeleteScopeChange: (scope: ReminderEditScope) => void
+	onEdit: () => void
+	onComplete: () => void
+	onDelete: () => void
+}) {
+	return (
+		<div className="flex items-start justify-between gap-3 rounded-md border px-3 py-2">
+			<div className="min-w-0 space-y-1">
+				<div className="flex flex-wrap items-center gap-2">
+					<span className="truncate text-sm font-medium">{reminder.title}</span>
+					<Badge variant={reminder.completedAt ? "secondary" : "outline"} className="text-xs">
+						{reminder.completedAt ? "Done" : reminder.priority}
+					</Badge>
+					{reminder.recurrence && (
+						<Badge variant="secondary" className="text-xs">
+							{formatRecurrence(reminder.recurrence)}
+						</Badge>
+					)}
+				</div>
+				<div className="text-xs text-muted-foreground">{formatDate(reminder.dueAt)}</div>
+				{reminder.notes && <div className="text-xs text-muted-foreground">{reminder.notes}</div>}
+			</div>
+			<div className="flex shrink-0 flex-wrap items-center justify-end gap-1">
+				{reminder.recurrence && (
+					<Select
+						value={deleteScope}
+						onValueChange={(value) => onDeleteScopeChange(value as ReminderEditScope)}
+						disabled={busy}
+					>
+						<SelectTrigger className="h-8 w-[86px] text-xs">
+							<SelectValue />
+						</SelectTrigger>
+						<SelectContent>
+							<SelectItem value="this-occurrence">This</SelectItem>
+							<SelectItem value="this-and-future">Future</SelectItem>
+							<SelectItem value="entire-series">All</SelectItem>
+						</SelectContent>
+					</Select>
+				)}
+				<Button size="sm" variant="ghost" onClick={onComplete} disabled={busy}>
+					{reminder.completedAt ? (
+						<RotateCcw className="size-3.5" />
+					) : (
+						<Check className="size-3.5" />
+					)}
+				</Button>
+				<Button size="sm" variant="ghost" onClick={onEdit} disabled={busy}>
+					<Pencil className="size-3.5" />
+				</Button>
+				<Button size="sm" variant="ghost" onClick={onDelete} disabled={busy}>
+					<Trash2 className="size-3.5 text-destructive" />
+				</Button>
+			</div>
+		</div>
+	)
+}
+
+function formToCreatePayload(form: ReminderFormState): Record<string, unknown> {
+	return {
+		title: form.title.trim(),
+		notes: form.notes.trim() || null,
+		dueAt: toIsoString(form.dueAt),
+		timeZone: localTimeZone(),
+		priority: form.priority,
+		recurrence: recurrenceValueFromForm(form),
+	}
+}
+
+function formToPatch(initial: ReminderFormState, form: ReminderFormState): Record<string, unknown> {
+	const patch: Record<string, unknown> = {}
+	const title = form.title.trim()
+	const notes = form.notes.trim() || null
+	const initialNotes = initial.notes.trim() || null
+
+	if (title !== initial.title.trim()) patch.title = title
+	if (notes !== initialNotes) patch.notes = notes
+	if (form.dueAt !== initial.dueAt) {
+		patch.dueAt = toIsoString(form.dueAt)
+		patch.timeZone = localTimeZone()
+	}
+	if (form.priority !== initial.priority) patch.priority = form.priority
+	if (form.scope !== "this-occurrence" && recurrenceChanged(initial, form)) {
+		patch.recurrence = recurrenceValueFromForm(form)
+	}
+
+	return patch
+}
+
+function recurrenceValueFromForm(form: ReminderFormState): ReminderRecurrence | null {
+	return form.recurs ? recurrenceFromForm(form) : null
+}
+
+function recurrenceFromForm(form: ReminderFormState): ReminderRecurrence {
+	const recurrence: ReminderRecurrence = {
+		frequency: form.frequency,
+		interval: Math.max(1, Number(form.interval) || 1),
+	}
+
+	const count = Number(form.count)
+	if (Number.isInteger(count) && count > 0) recurrence.count = count
+	if (form.until) recurrence.until = toIsoString(form.until)
+
+	return recurrence
+}
+
+function formFromReminder(reminder: ReminderFeedData): ReminderFormState {
+	return {
+		title: reminder.title,
+		notes: reminder.notes ?? "",
+		dueAt: toLocalInput(new Date(reminder.dueAt)),
+		priority: reminder.priority,
+		scope: reminder.recurrence ? "this-occurrence" : "entire-series",
+		recurs: reminder.recurrence !== null,
+		frequency: reminder.recurrence?.frequency ?? "daily",
+		interval: String(reminder.recurrence?.interval ?? 1),
+		count: reminder.recurrence?.count ? String(reminder.recurrence.count) : "",
+		until: reminder.recurrence?.until ? toLocalInput(new Date(reminder.recurrence.until)) : "",
+	}
+}
+
+function setFormField<TKey extends keyof ReminderFormState>(
+	setForm: Dispatch<SetStateAction<ReminderFormState>>,
+	key: TKey,
+	value: ReminderFormState[TKey],
+) {
+	setForm((prev) => ({ ...prev, [key]: value }))
+}
+
+function recurrenceChanged(initial: ReminderFormState, form: ReminderFormState): boolean {
+	return (
+		JSON.stringify(recurrenceValueFromForm(initial)) !==
+		JSON.stringify(recurrenceValueFromForm(form))
+	)
+}
+
+function reminderKey(reminder: ReminderFeedData): string {
+	return `${reminder.reminderId}:${reminder.occurrenceId}`
+}
+
+function isReminderItem(item: FeedItem): item is FeedItem & { data: ReminderFeedData } {
+	return (
+		item.sourceId === REMINDER_SOURCE_ID &&
+		typeof item.data.reminderId === "string" &&
+		typeof item.data.occurrenceId === "string" &&
+		typeof item.data.title === "string" &&
+		typeof item.data.originalDueAt === "string" &&
+		typeof item.data.dueAt === "string"
+	)
+}
+
+function toLocalInput(date: Date): string {
+	const offsetMs = date.getTimezoneOffset() * 60 * 1000
+	return new Date(date.getTime() - offsetMs).toISOString().slice(0, 16)
+}
+
+function toIsoString(value: string): string {
+	return new Date(value).toISOString()
+}
+
+function localTimeZone(): string {
+	return Intl.DateTimeFormat().resolvedOptions().timeZone
+}
+
+function formatDate(value: string): string {
+	return new Date(value).toLocaleString(undefined, {
+		month: "short",
+		day: "numeric",
+		hour: "numeric",
+		minute: "2-digit",
+	})
+}
+
+function formatRecurrence(recurrence: ReminderRecurrence): string {
+	return recurrence.interval === 1
+		? recurrence.frequency
+		: `${recurrence.frequency} / ${recurrence.interval}`
+}
+
+function formatScope(scope: ReminderEditScope): string {
+	switch (scope) {
+		case "this-occurrence":
+			return "this occurrence"
+		case "this-and-future":
+			return "this and future"
+		case "entire-series":
+			return "entire series"
+	}
+}

apps/admin-dashboard/src/components/source-config-panel.tsx

@@ -5,6 +5,7 @@ import { toast } from "sonner"
 
 import type { ConfigFieldDef, SourceDefinition } from "@/lib/api"
 
+import { ReminderCrudPanel } from "@/components/reminder-crud-panel"
 import { Badge } from "@/components/ui/badge"
 import { Button } from "@/components/ui/button"
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card"
@@ -20,13 +21,7 @@ import {
 import { Separator } from "@/components/ui/separator"
 import { Switch } from "@/components/ui/switch"
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip"
-import {
-	fetchSourceConfig,
-	pushLocation,
-	replaceSource,
-	updateProviderConfig,
-	updateSourceCredentials,
-} from "@/lib/api"
+import { fetchSourceConfig, pushLocation, replaceSource, updateProviderConfig } from "@/lib/api"
 
 interface SourceConfigPanelProps {
 	source: SourceDefinition
@@ -72,6 +67,20 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 		return creds
 	}
 
+	function hasUserConfigFields(): boolean {
+		return Object.values(source.fields).some((field) => !isCredentialField(field))
+	}
+
+	function buildReplaceBody(enabledValue: boolean): Parameters<typeof replaceSource>[1] {
+		const body: Parameters<typeof replaceSource>[1] = { enabled: enabledValue }
+
+		if (hasUserConfigFields()) {
+			body.config = getUserConfig()
+		}
+
+		return body
+	}
+
 	function invalidate() {
 		queryClient.invalidateQueries({ queryKey: ["sourceConfig", source.id] })
 		queryClient.invalidateQueries({ queryKey: ["configs"] })
@@ -80,23 +89,21 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 
 	const saveMutation = useMutation({
 		mutationFn: async () => {
-			const promises: Promise<void>[] = [
-				replaceSource(source.id, { enabled, config: getUserConfig() }),
-			]
-
 			const credentialFields = getCredentialFields()
 			const hasCredentials = Object.values(credentialFields).some(
 				(v) => typeof v === "string" && v.length > 0,
 			)
-			if (hasCredentials) {
-				if (source.perUserCredentials) {
-					promises.push(updateSourceCredentials(source.id, credentialFields))
-				} else {
-					promises.push(updateProviderConfig(source.id, { credentials: credentialFields }))
-				}
-			}
 
-			await Promise.all(promises)
+			const body = buildReplaceBody(enabled)
+			if (hasCredentials && source.perUserCredentials) {
+				body.credentials = credentialFields
+			}
+			await replaceSource(source.id, body)
+
+			// For non-per-user credentials (provider-level), still use the admin endpoint.
+			if (hasCredentials && !source.perUserCredentials) {
+				await updateProviderConfig(source.id, { credentials: credentialFields })
+			}
 		},
 		onSuccess() {
 			setDirty({})
@@ -109,8 +116,7 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 	})
 
 	const toggleMutation = useMutation({
-		mutationFn: (checked: boolean) =>
-			replaceSource(source.id, { enabled: checked, config: getUserConfig() }),
+		mutationFn: (checked: boolean) => replaceSource(source.id, buildReplaceBody(checked)),
 		onSuccess(_data, checked) {
 			invalidate()
 			toast.success(`Source ${checked ? "enabled" : "disabled"}`)
@@ -121,7 +127,7 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 	})
 
 	const deleteMutation = useMutation({
-		mutationFn: () => replaceSource(source.id, { enabled: false, config: {} }),
+		mutationFn: () => replaceSource(source.id, buildReplaceBody(false)),
 		onSuccess() {
 			setDirty({})
 			invalidate()
@@ -252,7 +258,7 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 			)}
 
 			{/* Always-on sources */}
-			{source.alwaysEnabled && source.id !== "aelis.location" && (
+			{source.alwaysEnabled && source.id !== "freya.location" && (
 				<>
 					<Separator />
 					<p className="text-sm text-muted-foreground">
@@ -261,7 +267,9 @@ export function SourceConfigPanel({ source, onUpdate }: SourceConfigPanelProps)
 				</>
 			)}
 
-			{source.id === "aelis.location" && <LocationCard />}
+			{source.id === "freya.location" && <LocationCard />}
+
+			{source.id === "freya.reminders" && enabled && <ReminderCrudPanel />}
 		</div>
 	)
 }
@@ -472,6 +480,17 @@ function FieldInput({
 		)
 	}
 
+	if (field.type === "boolean") {
+		return (
+			<div className="flex items-center justify-between gap-3 rounded-md border px-3 py-2">
+				<Label htmlFor={name} className="text-xs font-medium">
+					{labelContent}
+				</Label>
+				<Switch id={name} checked={value === true} onCheckedChange={onChange} disabled={disabled} />
+			</div>
+		)
+	}
+
 	return (
 		<div className="space-y-2">
 			<Label htmlFor={name} className="text-xs font-medium">
@@ -499,6 +518,8 @@ function buildInitialValues(
 			values[name] = saved[name]
 		} else if (field.defaultValue !== undefined) {
 			values[name] = field.defaultValue
+		} else if (field.type === "boolean") {
+			values[name] = false
 		} else if (field.type === "multiselect") {
 			values[name] = []
 		} else {

apps/admin-dashboard/src/lib/api.ts

@@ -9,12 +9,12 @@ function serverBase() {
 }
 
 export interface ConfigFieldDef {
-	type: "string" | "number" | "select" | "multiselect"
+	type: "string" | "number" | "select" | "multiselect" | "boolean"
 	label: string
 	required?: boolean
 	description?: string
 	secret?: boolean
-	defaultValue?: string | number | string[]
+	defaultValue?: string | number | string[] | boolean
 	options?: { label: string; value: string }[]
 }
 
@@ -36,14 +36,14 @@ export interface SourceConfig {
 
 const sourceDefinitions: SourceDefinition[] = [
 	{
-		id: "aelis.location",
+		id: "freya.location",
 		name: "Location",
 		description: "Device location provider. Always enabled as a dependency for other sources.",
 		alwaysEnabled: true,
 		fields: {},
 	},
 	{
-		id: "aelis.weather",
+		id: "freya.weather",
 		name: "WeatherKit",
 		description: "Apple WeatherKit weather data. Requires Apple Developer credentials.",
 		fields: {
@@ -81,7 +81,7 @@ const sourceDefinitions: SourceDefinition[] = [
 		},
 	},
 	{
-		id: "aelis.caldav",
+		id: "freya.caldav",
 		name: "CalDAV",
 		description: "Calendar events from any CalDAV server (Nextcloud, Radicale, Baikal, etc.).",
 		perUserCredentials: true,
@@ -114,12 +114,12 @@ const sourceDefinitions: SourceDefinition[] = [
 			timeZone: {
 				type: "string",
 				label: "Timezone",
-				description: "IANA timezone for determining \"today\" (e.g. Europe/London). Defaults to UTC.",
+				description: 'IANA timezone for determining "today" (e.g. Europe/London). Defaults to UTC.',
 			},
 		},
 	},
 	{
-		id: "aelis.tfl",
+		id: "freya.tfl",
 		name: "TfL",
 		description: "Transport for London tube line status alerts.",
 		fields: {
@@ -151,6 +151,49 @@ const sourceDefinitions: SourceDefinition[] = [
 			},
 		},
 	},
+	{
+		id: "freya.reminders",
+		name: "Reminders",
+		description: "One-off and recurring reminders in the contextual feed.",
+		fields: {
+			lookAheadMs: {
+				type: "number",
+				label: "Look-ahead Milliseconds",
+				defaultValue: 24 * 60 * 60 * 1000,
+				description: "How far into the future reminders should appear in the feed.",
+			},
+			lookBackMs: {
+				type: "number",
+				label: "Look-back Milliseconds",
+				defaultValue: 24 * 60 * 60 * 1000,
+				description: "How far into the past due reminders should remain visible.",
+			},
+			includeCompleted: {
+				type: "boolean",
+				label: "Include Completed",
+				defaultValue: false,
+				description: "Show completed reminder occurrences in the feed.",
+			},
+			defaultTimeZone: {
+				type: "string",
+				label: "Default Timezone",
+				defaultValue: "UTC",
+				description: "IANA timezone used when new reminders omit a timezone.",
+			},
+		},
+	},
+	{
+		id: "freya.web-search",
+		name: "Web Search",
+		description: "Exa web search action. Requires EXA_API_KEY on the backend.",
+		fields: {},
+	},
+	{
+		id: "freya.google-maps",
+		name: "Google Maps",
+		description: "Google Maps Grounding Lite MCP tools for places, weather, routes, and Place IDs.",
+		fields: {},
+	},
 ]
 
 export function fetchSources(): Promise<SourceDefinition[]> {
@@ -174,7 +217,7 @@ export async function fetchConfigs(): Promise<SourceConfig[]> {
 
 export async function replaceSource(
 	sourceId: string,
-	body: { enabled: boolean; config: unknown },
+	body: { enabled: boolean; config?: unknown; credentials?: Record<string, unknown> },
 ): Promise<void> {
 	const res = await fetch(`${serverBase()}/sources/${sourceId}`, {
 		method: "PUT",
@@ -220,6 +263,25 @@ export async function updateSourceCredentials(
 	}
 }
 
+export async function executeSourceAction(
+	sourceId: string,
+	actionId: string,
+	params: unknown,
+): Promise<unknown> {
+	const res = await fetch(`${serverBase()}/sources/${sourceId}/actions/${actionId}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		credentials: "include",
+		body: JSON.stringify(params),
+	})
+	if (!res.ok) {
+		const data = (await res.json()) as { error?: string }
+		throw new Error(data.error ?? `Failed to execute source action: ${res.status}`)
+	}
+	const data = (await res.json()) as { result: unknown }
+	return data.result
+}
+
 export interface LocationInput {
 	lat: number
 	lng: number

apps/admin-dashboard/src/lib/server-url.ts

@@ -1,4 +1,4 @@
-const STORAGE_KEY = "aelis-server-url"
+const STORAGE_KEY = "freya-server-url"
 const DEFAULT_URL = "https://3000--019cf276-6ed6-7529-a425-210182693908.eu-runner.flex.doptig.cloud"
 
 export function getServerUrl(): string {

apps/admin-dashboard/src/routes/_dashboard.tsx

@@ -8,6 +8,7 @@ import {
 	Link,
 } from "@tanstack/react-router"
 import {
+	Bell,
 	Calendar,
 	CalendarDays,
 	CircleDot,
@@ -15,6 +16,7 @@ import {
 	Loader2,
 	TrainFront,
 	LogOut,
+	Map as MapIcon,
 	MapPin,
 	Rss,
 	Server,
@@ -45,11 +47,13 @@ import { getSession, signOut } from "@/lib/auth"
 import { Route as rootRoute } from "./__root"
 
 const SOURCE_ICONS: Record<string, React.ComponentType<{ className?: string }>> = {
-	"aelis.location": MapPin,
-	"aelis.weather": CloudSun,
-	"aelis.caldav": CalendarDays,
-	"aelis.google-calendar": Calendar,
-	"aelis.tfl": TrainFront,
+	"freya.location": MapPin,
+	"freya.weather": CloudSun,
+	"freya.caldav": CalendarDays,
+	"freya.google-calendar": Calendar,
+	"freya.google-maps": MapIcon,
+	"freya.reminders": Bell,
+	"freya.tfl": TrainFront,
 }
 
 export const Route = createRoute({

apps/admin-dashboard/vite.config.ts

@@ -12,6 +12,7 @@ export default defineConfig({
 		},
 	},
 	server: {
+		host: "0.0.0.0",
 		port: 5174,
 		allowedHosts: true,
 	},

apps/aelis-backend/src/db/schema.ts

@@ -1,62 +0,0 @@
-import {
-	boolean,
-	customType,
-	index,
-	jsonb,
-	pgTable,
-	text,
-	timestamp,
-	unique,
-	uuid,
-} from "drizzle-orm/pg-core"
-
-// ---------------------------------------------------------------------------
-// Better Auth core tables
-// Re-exported from CLI-generated schema.
-// Regenerate with: bunx --bun auth@latest generate --config auth.ts --output src/db/auth-schema.ts
-// ---------------------------------------------------------------------------
-
-export {
-	user,
-	session,
-	account,
-	verification,
-	userRelations,
-	sessionRelations,
-	accountRelations,
-} from "./auth-schema.ts"
-
-import { user } from "./auth-schema.ts"
-
-// ---------------------------------------------------------------------------
-// AELIS — per-user source configuration
-// ---------------------------------------------------------------------------
-
-const bytea = customType<{ data: Buffer }>({
-	dataType() {
-		return "bytea"
-	},
-})
-
-export const userSources = pgTable(
-	"user_sources",
-	{
-		id: uuid("id").primaryKey().defaultRandom(),
-		userId: text("user_id")
-			.notNull()
-			.references(() => user.id, { onDelete: "cascade" }),
-		sourceId: text("source_id").notNull(),
-		enabled: boolean("enabled").notNull().default(true),
-		config: jsonb("config").default({}),
-		credentials: bytea("credentials"),
-		createdAt: timestamp("created_at").notNull().defaultNow(),
-		updatedAt: timestamp("updated_at")
-			.notNull()
-			.defaultNow()
-			.$onUpdate(() => new Date()),
-	},
-	(t) => [
-		unique("user_sources_user_id_source_id_unique").on(t.userId, t.sourceId),
-		index("user_sources_user_id_enabled_idx").on(t.userId, t.enabled),
-	],
-)

apps/freya-backend/drizzle/0000_wakeful_scorpion.sql

@@ -49,6 +49,33 @@ CREATE TABLE "user_sources" (
 	CONSTRAINT "user_sources_user_id_source_id_unique" UNIQUE("user_id","source_id")
 );
 --> statement-breakpoint
+CREATE TABLE "reminders" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" text NOT NULL,
+	"title" text NOT NULL,
+	"notes" text,
+	"due_at" timestamp NOT NULL,
+	"time_zone" text DEFAULT 'UTC' NOT NULL,
+	"recurrence" jsonb,
+	"priority" text DEFAULT 'normal' NOT NULL,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE "reminder_occurrence_overrides" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"user_id" text NOT NULL,
+	"reminder_id" uuid NOT NULL,
+	"occurrence_id" text NOT NULL,
+	"original_due_at" timestamp NOT NULL,
+	"patch" jsonb,
+	"completed_at" timestamp,
+	"deleted_at" timestamp,
+	"created_at" timestamp DEFAULT now() NOT NULL,
+	"updated_at" timestamp DEFAULT now() NOT NULL,
+	CONSTRAINT "reminder_occurrence_overrides_reminder_id_occurrence_id_unique" UNIQUE("reminder_id","occurrence_id")
+);
+--> statement-breakpoint
 CREATE TABLE "verification" (
 	"id" text PRIMARY KEY NOT NULL,
 	"identifier" text NOT NULL,
@@ -61,6 +88,13 @@ CREATE TABLE "verification" (
 ALTER TABLE "account" ADD CONSTRAINT "account_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "session" ADD CONSTRAINT "session_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
 ALTER TABLE "user_sources" ADD CONSTRAINT "user_sources_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "reminders" ADD CONSTRAINT "reminders_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "reminder_occurrence_overrides" ADD CONSTRAINT "reminder_occurrence_overrides_user_id_user_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."user"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
+ALTER TABLE "reminder_occurrence_overrides" ADD CONSTRAINT "reminder_occurrence_overrides_reminder_id_reminders_id_fk" FOREIGN KEY ("reminder_id") REFERENCES "public"."reminders"("id") ON DELETE cascade ON UPDATE no action;--> statement-breakpoint
 CREATE INDEX "account_userId_idx" ON "account" USING btree ("user_id");--> statement-breakpoint
 CREATE INDEX "session_userId_idx" ON "session" USING btree ("user_id");--> statement-breakpoint
-CREATE INDEX "verification_identifier_idx" ON "verification" USING btree ("identifier");
+CREATE INDEX "reminders_user_id_due_at_idx" ON "reminders" USING btree ("user_id","due_at");--> statement-breakpoint
+CREATE INDEX "reminders_user_id_updated_at_idx" ON "reminders" USING btree ("user_id","updated_at");--> statement-breakpoint
+CREATE INDEX "reminder_occurrence_overrides_user_id_reminder_id_idx" ON "reminder_occurrence_overrides" USING btree ("user_id","reminder_id");--> statement-breakpoint
+CREATE INDEX "reminder_occurrence_overrides_user_id_original_due_at_idx" ON "reminder_occurrence_overrides" USING btree ("user_id","original_due_at");--> statement-breakpoint
+CREATE INDEX "verification_identifier_idx" ON "verification" USING btree ("identifier");

apps/freya-backend/drizzle/meta/0000_snapshot.json

@@ -1,6 +1,6 @@
 {
-  "id": "d963322c-77e2-4ac9-bd3c-ca544c85ae35",
-  "prevId": "d8c59ec7-b686-41a7-a472-da29f3ab6727",
+  "id": "d8c59ec7-b686-41a7-a472-da29f3ab6727",
+  "prevId": "00000000-0000-0000-0000-000000000000",
   "version": "7",
   "dialect": "postgresql",
   "tables": {
@@ -346,29 +346,7 @@
           "default": "now()"
         }
       },
-      "indexes": {
-        "user_sources_user_id_enabled_idx": {
-          "name": "user_sources_user_id_enabled_idx",
-          "columns": [
-            {
-              "expression": "user_id",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            },
-            {
-              "expression": "enabled",
-              "isExpression": false,
-              "asc": true,
-              "nulls": "last"
-            }
-          ],
-          "isUnique": false,
-          "concurrently": false,
-          "method": "btree",
-          "with": {}
-        }
-      },
+      "indexes": {},
       "foreignKeys": {
         "user_sources_user_id_user_id_fk": {
           "name": "user_sources_user_id_user_id_fk",
@@ -463,6 +441,296 @@
       "policies": {},
       "checkConstraints": {},
       "isRLSEnabled": false
+    },
+    "public.reminders": {
+      "name": "reminders",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "due_at": {
+          "name": "due_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "time_zone": {
+          "name": "time_zone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'UTC'"
+        },
+        "recurrence": {
+          "name": "recurrence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'normal'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reminders_user_id_due_at_idx": {
+          "name": "reminders_user_id_due_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "due_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reminders_user_id_updated_at_idx": {
+          "name": "reminders_user_id_updated_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reminders_user_id_user_id_fk": {
+          "name": "reminders_user_id_user_id_fk",
+          "tableFrom": "reminders",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.reminder_occurrence_overrides": {
+      "name": "reminder_occurrence_overrides",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reminder_id": {
+          "name": "reminder_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "occurrence_id": {
+          "name": "occurrence_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_due_at": {
+          "name": "original_due_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "patch": {
+          "name": "patch",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reminder_occurrence_overrides_user_id_reminder_id_idx": {
+          "name": "reminder_occurrence_overrides_user_id_reminder_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "reminder_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reminder_occurrence_overrides_user_id_original_due_at_idx": {
+          "name": "reminder_occurrence_overrides_user_id_original_due_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "original_due_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reminder_occurrence_overrides_user_id_user_id_fk": {
+          "name": "reminder_occurrence_overrides_user_id_user_id_fk",
+          "tableFrom": "reminder_occurrence_overrides",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reminder_occurrence_overrides_reminder_id_reminders_id_fk": {
+          "name": "reminder_occurrence_overrides_reminder_id_reminders_id_fk",
+          "tableFrom": "reminder_occurrence_overrides",
+          "tableTo": "reminders",
+          "columnsFrom": [
+            "reminder_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "reminder_occurrence_overrides_reminder_id_occurrence_id_unique": {
+          "name": "reminder_occurrence_overrides_reminder_id_occurrence_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "reminder_id",
+            "occurrence_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
     }
   },
   "enums": {},
@@ -476,4 +744,4 @@
     "schemas": {},
     "tables": {}
   }
-}
+}

apps/freya-backend/drizzle/meta/0001_snapshot.json

@@ -1,6 +1,6 @@
 {
-  "id": "d8c59ec7-b686-41a7-a472-da29f3ab6727",
-  "prevId": "00000000-0000-0000-0000-000000000000",
+  "id": "d963322c-77e2-4ac9-bd3c-ca544c85ae35",
+  "prevId": "d8c59ec7-b686-41a7-a472-da29f3ab6727",
   "version": "7",
   "dialect": "postgresql",
   "tables": {
@@ -346,7 +346,29 @@
           "default": "now()"
         }
       },
-      "indexes": {},
+      "indexes": {
+        "user_sources_user_id_enabled_idx": {
+          "name": "user_sources_user_id_enabled_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "enabled",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
       "foreignKeys": {
         "user_sources_user_id_user_id_fk": {
           "name": "user_sources_user_id_user_id_fk",
@@ -441,6 +463,296 @@
       "policies": {},
       "checkConstraints": {},
       "isRLSEnabled": false
+    },
+    "public.reminders": {
+      "name": "reminders",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "notes": {
+          "name": "notes",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "due_at": {
+          "name": "due_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "time_zone": {
+          "name": "time_zone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'UTC'"
+        },
+        "recurrence": {
+          "name": "recurrence",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "priority": {
+          "name": "priority",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "'normal'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reminders_user_id_due_at_idx": {
+          "name": "reminders_user_id_due_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "due_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reminders_user_id_updated_at_idx": {
+          "name": "reminders_user_id_updated_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "updated_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reminders_user_id_user_id_fk": {
+          "name": "reminders_user_id_user_id_fk",
+          "tableFrom": "reminders",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    },
+    "public.reminder_occurrence_overrides": {
+      "name": "reminder_occurrence_overrides",
+      "schema": "",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "reminder_id": {
+          "name": "reminder_id",
+          "type": "uuid",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "occurrence_id": {
+          "name": "occurrence_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "original_due_at": {
+          "name": "original_due_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "patch": {
+          "name": "patch",
+          "type": "jsonb",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "timestamp",
+          "primaryKey": false,
+          "notNull": true,
+          "default": "now()"
+        }
+      },
+      "indexes": {
+        "reminder_occurrence_overrides_user_id_reminder_id_idx": {
+          "name": "reminder_occurrence_overrides_user_id_reminder_id_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "reminder_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        },
+        "reminder_occurrence_overrides_user_id_original_due_at_idx": {
+          "name": "reminder_occurrence_overrides_user_id_original_due_at_idx",
+          "columns": [
+            {
+              "expression": "user_id",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            },
+            {
+              "expression": "original_due_at",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "btree",
+          "with": {}
+        }
+      },
+      "foreignKeys": {
+        "reminder_occurrence_overrides_user_id_user_id_fk": {
+          "name": "reminder_occurrence_overrides_user_id_user_id_fk",
+          "tableFrom": "reminder_occurrence_overrides",
+          "tableTo": "user",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "reminder_occurrence_overrides_reminder_id_reminders_id_fk": {
+          "name": "reminder_occurrence_overrides_reminder_id_reminders_id_fk",
+          "tableFrom": "reminder_occurrence_overrides",
+          "tableTo": "reminders",
+          "columnsFrom": [
+            "reminder_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {
+        "reminder_occurrence_overrides_reminder_id_occurrence_id_unique": {
+          "name": "reminder_occurrence_overrides_reminder_id_occurrence_id_unique",
+          "nullsNotDistinct": false,
+          "columns": [
+            "reminder_id",
+            "occurrence_id"
+          ]
+        }
+      },
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
     }
   },
   "enums": {},
@@ -454,4 +766,4 @@
     "schemas": {},
     "tables": {}
   }
-}
+}

apps/freya-backend/drizzle/meta/_journal.json

@@ -17,4 +17,4 @@
       "breakpoints": true
     }
   ]
-}
+}

apps/freya-backend/package.json

@@ -1,5 +1,5 @@
 {
-	"name": "@aelis/backend",
+	"name": "@freya/backend",
 	"version": "0.0.0",
 	"type": "module",
 	"main": "src/server.ts",
@@ -15,12 +15,15 @@
 		"create-admin": "bun run src/scripts/create-admin.ts"
 	},
 	"dependencies": {
-		"@aelis/core": "workspace:*",
-		"@aelis/source-caldav": "workspace:*",
-		"@aelis/source-google-calendar": "workspace:*",
-		"@aelis/source-location": "workspace:*",
-		"@aelis/source-tfl": "workspace:*",
-		"@aelis/source-weatherkit": "workspace:*",
+		"@freya/core": "workspace:*",
+		"@freya/source-caldav": "workspace:*",
+		"@freya/source-google-calendar": "workspace:*",
+		"@freya/source-google-maps": "workspace:*",
+		"@freya/source-location": "workspace:*",
+		"@freya/source-reminders": "workspace:*",
+		"@freya/source-tfl": "workspace:*",
+		"@freya/source-weatherkit": "workspace:*",
+		"@freya/source-web-search": "workspace:*",
 		"@openrouter/sdk": "^0.9.11",
 		"arktype": "^2.1.29",
 		"better-auth": "^1",

apps/freya-backend/src/admin/http.test.ts

@@ -1,4 +1,4 @@
-import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@freya/core"
 
 import { describe, expect, mock, test } from "bun:test"
 import { Hono } from "hono"
@@ -118,9 +118,9 @@ const validWeatherConfig = {
 
 describe("PUT /api/admin/:sourceId/config", () => {
 	test("returns 404 for unknown provider", async () => {
-		const { app } = createApp([createStubProvider("aelis.location")])
+		const { app } = createApp([createStubProvider("freya.location")])
 
-		const res = await app.request("/api/admin/aelis.nonexistent/config", {
+		const res = await app.request("/api/admin/freya.nonexistent/config", {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ key: "value" }),
@@ -132,9 +132,9 @@ describe("PUT /api/admin/:sourceId/config", () => {
 	})
 
 	test("returns 404 for provider without runtime config support", async () => {
-		const { app } = createApp([createStubProvider("aelis.location")])
+		const { app } = createApp([createStubProvider("freya.location")])
 
-		const res = await app.request("/api/admin/aelis.location/config", {
+		const res = await app.request("/api/admin/freya.location/config", {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ key: "value" }),
@@ -146,9 +146,9 @@ describe("PUT /api/admin/:sourceId/config", () => {
 	})
 
 	test("returns 400 for invalid JSON body", async () => {
-		const { app } = createApp([createStubProvider("aelis.weather")])
+		const { app } = createApp([createStubProvider("freya.weather")])
 
-		const res = await app.request("/api/admin/aelis.weather/config", {
+		const res = await app.request("/api/admin/freya.weather/config", {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: "not json",
@@ -160,9 +160,9 @@ describe("PUT /api/admin/:sourceId/config", () => {
 	})
 
 	test("returns 400 when weather config fails validation", async () => {
-		const { app } = createApp([createStubProvider("aelis.weather")])
+		const { app } = createApp([createStubProvider("freya.weather")])
 
-		const res = await app.request("/api/admin/aelis.weather/config", {
+		const res = await app.request("/api/admin/freya.weather/config", {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify({ credentials: { privateKey: 123 } }),
@@ -174,11 +174,11 @@ describe("PUT /api/admin/:sourceId/config", () => {
 	})
 
 	test("returns 204 and applies valid weather config", async () => {
-		const { app, sessionManager } = createApp([createStubProvider("aelis.weather")])
+		const { app, sessionManager } = createApp([createStubProvider("freya.weather")])
 
-		const originalProvider = sessionManager.getProvider("aelis.weather")
+		const originalProvider = sessionManager.getProvider("freya.weather")
 
-		const res = await app.request("/api/admin/aelis.weather/config", {
+		const res = await app.request("/api/admin/freya.weather/config", {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(validWeatherConfig),
@@ -187,9 +187,9 @@ describe("PUT /api/admin/:sourceId/config", () => {
 		expect(res.status).toBe(204)
 
 		// Provider was replaced with a new instance
-		const provider = sessionManager.getProvider("aelis.weather")
+		const provider = sessionManager.getProvider("freya.weather")
 		expect(provider).toBeDefined()
-		expect(provider!.sourceId).toBe("aelis.weather")
+		expect(provider!.sourceId).toBe("freya.weather")
 		expect(provider).not.toBe(originalProvider)
 	})
 })

apps/freya-backend/src/admin/http.ts

@@ -60,7 +60,7 @@ async function handleUpdateProviderConfig(c: Context<Env>) {
 	}
 
 	switch (sourceId) {
-		case "aelis.weather": {
+		case "freya.weather": {
 			const parsed = WeatherKitSourceProviderConfig(body)
 			if (parsed instanceof type.errors) {
 				return c.json({ error: parsed.summary }, 400)

apps/freya-backend/src/auth/admin-middleware.test.ts

@@ -1,5 +1,5 @@
-import { Hono } from "hono"
 import { describe, expect, test } from "bun:test"
+import { Hono } from "hono"
 
 import type { Auth } from "./index.ts"
 import type { AuthSession, AuthUser } from "./session.ts"

apps/freya-backend/src/auth/session-middleware.ts

@@ -79,7 +79,7 @@ export function mockAuthSessionMiddleware(userId?: string): AuthSessionMiddlewar
 		const user: AuthUser = {
 			id: "k7Gx2mPqRvNwYs9TdLfA4bHcJeUo1iZn",
 			name: "Dev User",
-			email: "dev@aelis.local",
+			email: "dev@freya.local",
 			emailVerified: true,
 			image: null,
 			createdAt: now,
@@ -96,7 +96,7 @@ export function mockAuthSessionMiddleware(userId?: string): AuthSessionMiddlewar
 			token: "Vb9CxNfRm2KwQs7TjPeA5dLhYg0UoZi4",
 			expiresAt,
 			ipAddress: "127.0.0.1",
-			userAgent: "aelis-dev",
+			userAgent: "freya-dev",
 			createdAt: now,
 			updatedAt: now,
 		}

apps/freya-backend/src/caldav/provider.test.ts

@@ -5,8 +5,8 @@ import { CalDavSourceProvider } from "./provider.ts"
 describe("CalDavSourceProvider", () => {
 	const provider = new CalDavSourceProvider()
 
-	test("sourceId is aelis.caldav", () => {
-		expect(provider.sourceId).toBe("aelis.caldav")
+	test("sourceId is freya.caldav", () => {
+		expect(provider.sourceId).toBe("freya.caldav")
 	})
 
 	test("throws when credentials are null", async () => {
@@ -68,7 +68,7 @@ describe("CalDavSourceProvider", () => {
 
 		const source = await provider.feedSourceForUser("user-1", config, credentials)
 		expect(source).toBeDefined()
-		expect(source.id).toBe("aelis.caldav")
+		expect(source.id).toBe("freya.caldav")
 	})
 
 	test("returns CalDavSource with minimal config", async () => {
@@ -80,6 +80,6 @@ describe("CalDavSourceProvider", () => {
 
 		const source = await provider.feedSourceForUser("user-1", config, credentials)
 		expect(source).toBeDefined()
-		expect(source.id).toBe("aelis.caldav")
+		expect(source.id).toBe("freya.caldav")
 	})
 })

apps/freya-backend/src/caldav/provider.ts

@@ -1,4 +1,4 @@
-import { CalDavSource } from "@aelis/source-caldav"
+import { CalDavSource } from "@freya/source-caldav"
 import { type } from "arktype"
 
 import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
@@ -19,7 +19,7 @@ const caldavCredentials = type({
 })
 
 export class CalDavSourceProvider implements FeedSourceProvider {
-	readonly sourceId = "aelis.caldav"
+	readonly sourceId = "freya.caldav"
 	readonly configSchema = caldavConfig
 
 	async feedSourceForUser(
@@ -33,12 +33,12 @@ export class CalDavSourceProvider implements FeedSourceProvider {
 		}
 
 		if (!credentials) {
-			throw new InvalidSourceCredentialsError("aelis.caldav", "No CalDAV credentials configured")
+			throw new InvalidSourceCredentialsError("freya.caldav", "No CalDAV credentials configured")
 		}
 
 		const creds = caldavCredentials(credentials)
 		if (creds instanceof type.errors) {
-			throw new InvalidSourceCredentialsError("aelis.caldav", creds.summary)
+			throw new InvalidSourceCredentialsError("freya.caldav", creds.summary)
 		}
 
 		return new CalDavSource({

apps/freya-backend/src/db/index.ts

@@ -1,9 +1,12 @@
+import type { PgDatabase } from "drizzle-orm/pg-core"
+
 import { SQL } from "bun"
-import { drizzle, type BunSQLDatabase } from "drizzle-orm/bun-sql"
+import { drizzle, type BunSQLQueryResultHKT } from "drizzle-orm/bun-sql"
 
 import * as schema from "./schema.ts"
 
-export type Database = BunSQLDatabase<typeof schema>
+/** Covers both the top-level drizzle instance and transaction handles. */
+export type Database = PgDatabase<BunSQLQueryResultHKT, typeof schema>
 
 export interface DatabaseConnection {
 	db: Database

apps/freya-backend/src/db/schema.ts

@@ -0,0 +1,125 @@
+import {
+	boolean,
+	customType,
+	index,
+	jsonb,
+	pgTable,
+	text,
+	timestamp,
+	unique,
+	uuid,
+} from "drizzle-orm/pg-core"
+
+// ---------------------------------------------------------------------------
+// Better Auth core tables
+// Re-exported from CLI-generated schema.
+// Regenerate with: bunx --bun auth@latest generate --config auth.ts --output src/db/auth-schema.ts
+// ---------------------------------------------------------------------------
+
+export {
+	user,
+	session,
+	account,
+	verification,
+	userRelations,
+	sessionRelations,
+	accountRelations,
+} from "./auth-schema.ts"
+
+import { user } from "./auth-schema.ts"
+
+// ---------------------------------------------------------------------------
+// FREYA — per-user source configuration
+// ---------------------------------------------------------------------------
+
+const bytea = customType<{ data: Buffer }>({
+	dataType() {
+		return "bytea"
+	},
+})
+
+export const userSources = pgTable(
+	"user_sources",
+	{
+		id: uuid("id").primaryKey().defaultRandom(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		sourceId: text("source_id").notNull(),
+		enabled: boolean("enabled").notNull().default(true),
+		config: jsonb("config").default({}),
+		credentials: bytea("credentials"),
+		createdAt: timestamp("created_at").notNull().defaultNow(),
+		updatedAt: timestamp("updated_at")
+			.notNull()
+			.defaultNow()
+			.$onUpdate(() => new Date()),
+	},
+	(t) => [
+		unique("user_sources_user_id_source_id_unique").on(t.userId, t.sourceId),
+		index("user_sources_user_id_enabled_idx").on(t.userId, t.enabled),
+	],
+)
+
+// ---------------------------------------------------------------------------
+// FREYA — reminders source storage
+// ---------------------------------------------------------------------------
+
+export const reminders = pgTable(
+	"reminders",
+	{
+		id: uuid("id").primaryKey().defaultRandom(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		title: text("title").notNull(),
+		notes: text("notes"),
+		dueAt: timestamp("due_at").notNull(),
+		timeZone: text("time_zone").notNull().default("UTC"),
+		recurrence: jsonb("recurrence"),
+		priority: text("priority").notNull().default("normal"),
+		createdAt: timestamp("created_at").notNull().defaultNow(),
+		updatedAt: timestamp("updated_at")
+			.notNull()
+			.defaultNow()
+			.$onUpdate(() => new Date()),
+	},
+	(t) => [
+		index("reminders_user_id_due_at_idx").on(t.userId, t.dueAt),
+		index("reminders_user_id_updated_at_idx").on(t.userId, t.updatedAt),
+	],
+)
+
+export const reminderOccurrenceOverrides = pgTable(
+	"reminder_occurrence_overrides",
+	{
+		id: uuid("id").primaryKey().defaultRandom(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		reminderId: uuid("reminder_id")
+			.notNull()
+			.references(() => reminders.id, { onDelete: "cascade" }),
+		occurrenceId: text("occurrence_id").notNull(),
+		originalDueAt: timestamp("original_due_at").notNull(),
+		patch: jsonb("patch"),
+		completedAt: timestamp("completed_at"),
+		deletedAt: timestamp("deleted_at"),
+		createdAt: timestamp("created_at").notNull().defaultNow(),
+		updatedAt: timestamp("updated_at")
+			.notNull()
+			.defaultNow()
+			.$onUpdate(() => new Date()),
+	},
+	(t) => [
+		unique("reminder_occurrence_overrides_reminder_id_occurrence_id_unique").on(
+			t.reminderId,
+			t.occurrenceId,
+		),
+		index("reminder_occurrence_overrides_user_id_reminder_id_idx").on(t.userId, t.reminderId),
+		index("reminder_occurrence_overrides_user_id_original_due_at_idx").on(
+			t.userId,
+			t.originalDueAt,
+		),
+	],
+)

apps/freya-backend/src/engine/http.test.ts

@@ -1,6 +1,6 @@
-import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@freya/core"
 
-import { contextKey } from "@aelis/core"
+import { contextKey } from "@freya/core"
 import { describe, expect, mock, spyOn, test } from "bun:test"
 import { Hono } from "hono"
 
@@ -244,7 +244,7 @@ describe("GET /api/feed", () => {
 })
 
 describe("GET /api/context", () => {
-	const weatherKey = contextKey("aelis.weather", "weather")
+	const weatherKey = contextKey("freya.weather", "weather")
 	const weatherData = { temperature: 20, condition: "Clear" }
 	const contextEntries: readonly ContextEntry[] = [[weatherKey, weatherData]]
 
@@ -274,7 +274,7 @@ describe("GET /api/context", () => {
 		const manager = new UserSessionManager({ db: fakeDb, providers: [] })
 		const app = buildTestApp(manager)
 
-		const res = await app.request('/api/context?key=["aelis.weather","weather"]')
+		const res = await app.request('/api/context?key=["freya.weather","weather"]')
 
 		expect(res.status).toBe(401)
 	})
@@ -332,7 +332,7 @@ describe("GET /api/context", () => {
 	test("returns 400 when match param is invalid", async () => {
 		const { app } = await buildContextApp("user-1")
 
-		const res = await app.request('/api/context?key=["aelis.weather"]&match=invalid')
+		const res = await app.request('/api/context?key=["freya.weather"]&match=invalid')
 
 		expect(res.status).toBe(400)
 		const body = (await res.json()) as { error: string }
@@ -343,7 +343,7 @@ describe("GET /api/context", () => {
 		const { app, session } = await buildContextApp("user-1")
 		await session.engine.refresh()
 
-		const res = await app.request('/api/context?key=["aelis.weather","weather"]&match=exact')
+		const res = await app.request('/api/context?key=["freya.weather","weather"]&match=exact')
 
 		expect(res.status).toBe(200)
 		const body = (await res.json()) as { match: string; value: unknown }
@@ -355,7 +355,7 @@ describe("GET /api/context", () => {
 		const { app, session } = await buildContextApp("user-1")
 		await session.engine.refresh()
 
-		const res = await app.request('/api/context?key=["aelis.weather"]&match=exact')
+		const res = await app.request('/api/context?key=["freya.weather"]&match=exact')
 
 		expect(res.status).toBe(404)
 	})
@@ -364,7 +364,7 @@ describe("GET /api/context", () => {
 		const { app, session } = await buildContextApp("user-1")
 		await session.engine.refresh()
 
-		const res = await app.request('/api/context?key=["aelis.weather"]&match=prefix')
+		const res = await app.request('/api/context?key=["freya.weather"]&match=prefix')
 
 		expect(res.status).toBe(200)
 		const body = (await res.json()) as {
@@ -373,7 +373,7 @@ describe("GET /api/context", () => {
 		}
 		expect(body.match).toBe("prefix")
 		expect(body.entries).toHaveLength(1)
-		expect(body.entries[0]!.key).toEqual(["aelis.weather", "weather"])
+		expect(body.entries[0]!.key).toEqual(["freya.weather", "weather"])
 		expect(body.entries[0]!.value).toEqual(weatherData)
 	})
 
@@ -381,7 +381,7 @@ describe("GET /api/context", () => {
 		const { app, session } = await buildContextApp("user-1")
 		await session.engine.refresh()
 
-		const res = await app.request('/api/context?key=["aelis.weather","weather"]')
+		const res = await app.request('/api/context?key=["freya.weather","weather"]')
 
 		expect(res.status).toBe(200)
 		const body = (await res.json()) as { match: string; value: unknown }
@@ -393,7 +393,7 @@ describe("GET /api/context", () => {
 		const { app, session } = await buildContextApp("user-1")
 		await session.engine.refresh()
 
-		const res = await app.request('/api/context?key=["aelis.weather"]')
+		const res = await app.request('/api/context?key=["freya.weather"]')
 
 		expect(res.status).toBe(200)
 		const body = (await res.json()) as {

apps/freya-backend/src/engine/http.ts

@@ -1,6 +1,6 @@
 import type { Context, Hono } from "hono"
 
-import { contextKey } from "@aelis/core"
+import { contextKey } from "@freya/core"
 import { createMiddleware } from "hono/factory"
 
 import type { AuthSessionMiddleware } from "../auth/session-middleware.ts"

apps/freya-backend/src/enhancement/enhance-feed.ts

@@ -1,4 +1,4 @@
-import type { FeedItem } from "@aelis/core"
+import type { FeedItem } from "@freya/core"
 
 import type { LlmClient } from "./llm-client.ts"
 
@@ -47,5 +47,3 @@ export function createFeedEnhancer(config: FeedEnhancerConfig): FeedEnhancer {
 		return mergeEnhancement(items, result, currentTime)
 	}
 }
-
-

apps/freya-backend/src/enhancement/merge.test.ts

@@ -1,4 +1,4 @@
-import type { FeedItem } from "@aelis/core"
+import type { FeedItem } from "@freya/core"
 
 import { describe, expect, test } from "bun:test"
 

apps/freya-backend/src/enhancement/merge.ts

@@ -1,8 +1,8 @@
-import type { FeedItem } from "@aelis/core"
+import type { FeedItem } from "@freya/core"
 
 import type { EnhancementResult } from "./schema.ts"
 
-const ENHANCEMENT_SOURCE_ID = "aelis.enhancement"
+const ENHANCEMENT_SOURCE_ID = "freya.enhancement"
 
 /**
  * Merges an EnhancementResult into feed items.

apps/freya-backend/src/enhancement/prompt-builder.test.ts

@@ -1,4 +1,4 @@
-import type { FeedItem } from "@aelis/core"
+import type { FeedItem } from "@freya/core"
 
 import { describe, expect, test } from "bun:test"
 

apps/freya-backend/src/enhancement/prompt-builder.ts

@@ -1,7 +1,7 @@
-import type { FeedItem } from "@aelis/core"
+import type { FeedItem } from "@freya/core"
 
-import { CalDavFeedItemType } from "@aelis/source-caldav"
-import { CalendarFeedItemType } from "@aelis/source-google-calendar"
+import { CalDavFeedItemType } from "@freya/source-caldav"
+import { CalendarFeedItemType } from "@freya/source-google-calendar"
 
 import systemPromptBase from "./prompts/system.txt"
 
@@ -36,8 +36,7 @@ export function buildPrompt(
 
 	for (const item of items) {
 		const hasUnfilledSlots =
-			item.slots &&
-			Object.values(item.slots).some((slot) => slot.content === null)
+			item.slots && Object.values(item.slots).some((slot) => slot.content === null)
 
 		if (hasUnfilledSlots) {
 			enhanceItems.push({
@@ -79,9 +78,7 @@ export function buildPrompt(
  */
 export function hasUnfilledSlots(items: FeedItem[]): boolean {
 	return items.some(
-		(item) =>
-			item.slots &&
-			Object.values(item.slots).some((slot) => slot.content === null),
+		(item) => item.slots && Object.values(item.slots).some((slot) => slot.content === null),
 	)
 }
 
@@ -129,7 +126,20 @@ function extractCalendarEntry(item: FeedItem): CalendarEntry | null {
 }
 
 const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"] as const
-const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] as const
+const MONTHS = [
+	"Jan",
+	"Feb",
+	"Mar",
+	"Apr",
+	"May",
+	"Jun",
+	"Jul",
+	"Aug",
+	"Sep",
+	"Oct",
+	"Nov",
+	"Dec",
+] as const
 
 function pad2(n: number): string {
 	return n.toString().padStart(2, "0")
@@ -144,7 +154,11 @@ function formatDayShort(date: Date): string {
 }
 
 function formatDayLabel(date: Date, currentTime: Date): string {
-	const currentDay = Date.UTC(currentTime.getUTCFullYear(), currentTime.getUTCMonth(), currentTime.getUTCDate())
+	const currentDay = Date.UTC(
+		currentTime.getUTCFullYear(),
+		currentTime.getUTCMonth(),
+		currentTime.getUTCDate(),
+	)
 	const targetDay = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate())
 	const diffDays = Math.round((targetDay - currentDay) / (1000 * 60 * 60 * 24))
 

apps/freya-backend/src/enhancement/prompts/system.txt

@@ -1,4 +1,4 @@
-You are AELIS, a personal assistant. You enhance a user's feed by filling slots and optionally generating synthetic items.
+You are FREYA, a personal assistant. You enhance a user's feed by filling slots and optionally generating synthetic items.
 
 The user message is a JSON object with:
 - "items": feed items with data and named slots to fill. Each slot has a description of what to write.

apps/freya-backend/src/enhancement/schema.test.ts

@@ -135,9 +135,7 @@ describe("schema sync", () => {
 
 			// JSON Schema structure matches
 			const jsonSchema = enhancementResultJsonSchema
-			expect(Object.keys(jsonSchema.properties).sort()).toEqual(
-				Object.keys(payload).sort(),
-			)
+			expect(Object.keys(jsonSchema.properties).sort()).toEqual(Object.keys(payload).sort())
 			expect([...jsonSchema.required].sort()).toEqual(Object.keys(payload).sort())
 
 			// syntheticItems item schema has the right required fields
@@ -167,11 +165,7 @@ describe("schema sync", () => {
 
 		// JSON Schema only allows string or null for slot values
 		const slotValueSchema =
-			enhancementResultJsonSchema.properties.slotFills.additionalProperties
-				.additionalProperties
-		expect(slotValueSchema.anyOf).toEqual([
-			{ type: "string" },
-			{ type: "null" },
-		])
+			enhancementResultJsonSchema.properties.slotFills.additionalProperties.additionalProperties
+		expect(slotValueSchema.anyOf).toEqual([{ type: "string" }, { type: "null" }])
 	})
 })

apps/freya-backend/src/google-maps/provider.test.ts

@@ -0,0 +1,55 @@
+import type { GoogleMapsSourceOptions } from "@freya/source-google-maps"
+
+import { describe, expect, test } from "bun:test"
+
+import { GoogleMapsSourceProvider } from "./provider.ts"
+
+type McpClient = NonNullable<GoogleMapsSourceOptions["client"]>
+
+class MockMcpClient implements McpClient {
+	async listTools(): ReturnType<McpClient["listTools"]> {
+		return { tools: [] }
+	}
+
+	async readResource(
+		_params: Parameters<McpClient["readResource"]>[0],
+	): ReturnType<McpClient["readResource"]> {
+		throw new Error("unexpected resource read")
+	}
+
+	async callTool(_params: Parameters<McpClient["callTool"]>[0]): ReturnType<McpClient["callTool"]> {
+		return { structuredContent: {} }
+	}
+}
+
+describe("GoogleMapsSourceProvider", () => {
+	test("sourceId is freya.google-maps", () => {
+		const provider = new GoogleMapsSourceProvider({ apiKey: "key" })
+		expect(provider.sourceId).toBe("freya.google-maps")
+	})
+
+	test("throws when service API key is empty", () => {
+		expect(() => new GoogleMapsSourceProvider({ apiKey: "" })).toThrow(
+			"Google Maps API key must be configured",
+		)
+	})
+
+	test("returns source with service API key", async () => {
+		const provider = new GoogleMapsSourceProvider({ apiKey: "key" })
+
+		const source = await provider.feedSourceForUser("user-1", {}, null)
+
+		expect(source.id).toBe("freya.google-maps")
+	})
+
+	test("allows injected test client with service API key", async () => {
+		const provider = new GoogleMapsSourceProvider({
+			apiKey: "key",
+			client: new MockMcpClient(),
+		})
+
+		const source = await provider.feedSourceForUser("user-1", {}, null)
+
+		expect(source.id).toBe("freya.google-maps")
+	})
+})

apps/freya-backend/src/google-maps/provider.ts

@@ -0,0 +1,39 @@
+import { GoogleMapsSource, type GoogleMapsSourceOptions } from "@freya/source-google-maps"
+
+import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
+
+export interface GoogleMapsSourceProviderOptions {
+	readonly apiKey: string
+	readonly client?: GoogleMapsSourceOptions["client"]
+}
+
+export class GoogleMapsSourceProvider implements FeedSourceProvider {
+	readonly sourceId = "freya.google-maps"
+
+	private readonly apiKey: string
+	private readonly client: GoogleMapsSourceProviderOptions["client"]
+
+	constructor(options: GoogleMapsSourceProviderOptions) {
+		if (!nonEmptyString(options.apiKey)) {
+			throw new Error("Google Maps API key must be configured")
+		}
+
+		this.apiKey = options.apiKey
+		this.client = options.client
+	}
+
+	async feedSourceForUser(
+		_userId: string,
+		_config: unknown,
+		_credentials: unknown,
+	): Promise<GoogleMapsSource> {
+		return new GoogleMapsSource({
+			apiKey: this.apiKey,
+			client: this.client,
+		})
+	}
+}
+
+function nonEmptyString(value: string): boolean {
+	return typeof value === "string" && value.trim().length > 0
+}

apps/freya-backend/src/lib/crypto.test.ts

@@ -1,5 +1,5 @@
-import { randomBytes } from "node:crypto"
 import { describe, expect, test } from "bun:test"
+import { randomBytes } from "node:crypto"
 
 import { CredentialEncryptor } from "./crypto.ts"
 

apps/freya-backend/src/lib/env.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, test } from "bun:test"
+
+import { ensureEnv } from "./env.ts"
+
+describe("ensureEnv", () => {
+	test("returns trimmed required env values", () => {
+		const env = ensureEnv({
+			BETTER_AUTH_SECRET: " auth-secret ",
+			CREDENTIAL_ENCRYPTION_KEY: " credential-key ",
+			DATABASE_URL: " postgres://example ",
+			EXA_API_KEY: " exa-key ",
+			GOOGLE_MAPS_API_KEY: " google-maps-key ",
+			OPENROUTER_API_KEY: " openrouter-key ",
+			OPENROUTER_MODEL: " model-name ",
+			TFL_API_KEY: " tfl-key ",
+			WEATHERKIT_KEY_ID: " weather-key-id ",
+			WEATHERKIT_PRIVATE_KEY: " weather-private-key ",
+			WEATHERKIT_SERVICE_ID: " weather-service-id ",
+			WEATHERKIT_TEAM_ID: " weather-team-id ",
+		})
+
+		expect(env).toEqual({
+			betterAuthSecret: "auth-secret",
+			credentialEncryptionKey: "credential-key",
+			databaseUrl: "postgres://example",
+			exaApiKey: "exa-key",
+			googleMapsApiKey: "google-maps-key",
+			openrouterApiKey: "openrouter-key",
+			openrouterModel: "model-name",
+			tflApiKey: "tfl-key",
+			weatherkitKeyId: "weather-key-id",
+			weatherkitPrivateKey: "weather-private-key",
+			weatherkitServiceId: "weather-service-id",
+			weatherkitTeamId: "weather-team-id",
+		})
+	})
+
+	test("does not allow the old Google Maps MCP fallback key", () => {
+		expect(() =>
+			ensureEnv({
+				BETTER_AUTH_SECRET: "auth-secret",
+				CREDENTIAL_ENCRYPTION_KEY: "credential-key",
+				DATABASE_URL: "postgres://example",
+				EXA_API_KEY: "exa-key",
+				GOOGLE_MAPS_MCP_API_KEY: "google-maps-mcp-key",
+				OPENROUTER_API_KEY: "openrouter-key",
+				TFL_API_KEY: "tfl-key",
+				WEATHERKIT_KEY_ID: "weather-key-id",
+				WEATHERKIT_PRIVATE_KEY: "weather-private-key",
+				WEATHERKIT_SERVICE_ID: "weather-service-id",
+				WEATHERKIT_TEAM_ID: "weather-team-id",
+			}),
+		).toThrow("Missing required environment variables: GOOGLE_MAPS_API_KEY")
+	})
+
+	test("allows openrouter model to be omitted", () => {
+		const env = ensureEnv({
+			BETTER_AUTH_SECRET: "auth-secret",
+			CREDENTIAL_ENCRYPTION_KEY: "credential-key",
+			DATABASE_URL: "postgres://example",
+			EXA_API_KEY: "exa-key",
+			GOOGLE_MAPS_API_KEY: "google-maps-key",
+			OPENROUTER_API_KEY: "openrouter-key",
+			TFL_API_KEY: "tfl-key",
+			WEATHERKIT_KEY_ID: "weather-key-id",
+			WEATHERKIT_PRIVATE_KEY: "weather-private-key",
+			WEATHERKIT_SERVICE_ID: "weather-service-id",
+			WEATHERKIT_TEAM_ID: "weather-team-id",
+		})
+
+		expect(env.googleMapsApiKey).toBe("google-maps-key")
+		expect(env.openrouterModel).toBeUndefined()
+	})
+
+	test("throws with all missing required env names", () => {
+		expect(() => ensureEnv({})).toThrow(
+			"Missing required environment variables: BETTER_AUTH_SECRET, CREDENTIAL_ENCRYPTION_KEY, DATABASE_URL, EXA_API_KEY, OPENROUTER_API_KEY, TFL_API_KEY, WEATHERKIT_PRIVATE_KEY, WEATHERKIT_KEY_ID, WEATHERKIT_TEAM_ID, WEATHERKIT_SERVICE_ID, GOOGLE_MAPS_API_KEY",
+		)
+	})
+
+	test("treats whitespace-only values as missing", () => {
+		expect(() =>
+			ensureEnv({
+				BETTER_AUTH_SECRET: "auth-secret",
+				CREDENTIAL_ENCRYPTION_KEY: "credential-key",
+				DATABASE_URL: "postgres://example",
+				EXA_API_KEY: " ",
+				GOOGLE_MAPS_API_KEY: "google-maps-key",
+				OPENROUTER_API_KEY: "openrouter-key",
+				TFL_API_KEY: "tfl-key",
+				WEATHERKIT_KEY_ID: "weather-key-id",
+				WEATHERKIT_PRIVATE_KEY: "weather-private-key",
+				WEATHERKIT_SERVICE_ID: "weather-service-id",
+				WEATHERKIT_TEAM_ID: "weather-team-id",
+			}),
+		).toThrow("Missing required environment variables: EXA_API_KEY")
+	})
+})

apps/freya-backend/src/lib/env.ts

@@ -0,0 +1,69 @@
+export interface ServerEnv {
+	betterAuthSecret: string
+	credentialEncryptionKey: string
+	databaseUrl: string
+	exaApiKey: string
+	googleMapsApiKey: string
+	openrouterApiKey: string
+	openrouterModel: string | undefined
+	tflApiKey: string
+	weatherkitKeyId: string
+	weatherkitPrivateKey: string
+	weatherkitServiceId: string
+	weatherkitTeamId: string
+}
+
+export function ensureEnv(env: Record<string, string | undefined>): ServerEnv {
+	const missing: string[] = []
+
+	const betterAuthSecret = readRequiredEnv(env, "BETTER_AUTH_SECRET", missing)
+	const credentialEncryptionKey = readRequiredEnv(env, "CREDENTIAL_ENCRYPTION_KEY", missing)
+	const databaseUrl = readRequiredEnv(env, "DATABASE_URL", missing)
+	const exaApiKey = readRequiredEnv(env, "EXA_API_KEY", missing)
+	const openrouterApiKey = readRequiredEnv(env, "OPENROUTER_API_KEY", missing)
+	const tflApiKey = readRequiredEnv(env, "TFL_API_KEY", missing)
+	const weatherkitPrivateKey = readRequiredEnv(env, "WEATHERKIT_PRIVATE_KEY", missing)
+	const weatherkitKeyId = readRequiredEnv(env, "WEATHERKIT_KEY_ID", missing)
+	const weatherkitTeamId = readRequiredEnv(env, "WEATHERKIT_TEAM_ID", missing)
+	const weatherkitServiceId = readRequiredEnv(env, "WEATHERKIT_SERVICE_ID", missing)
+	const googleMapsApiKey = readRequiredEnv(env, "GOOGLE_MAPS_API_KEY", missing)
+
+	if (missing.length > 0) {
+		throw new Error(`Missing required environment variables: ${missing.join(", ")}`)
+	}
+
+	return {
+		betterAuthSecret,
+		credentialEncryptionKey,
+		databaseUrl,
+		exaApiKey,
+		googleMapsApiKey,
+		openrouterApiKey,
+		openrouterModel: readOptionalEnv(env, "OPENROUTER_MODEL"),
+		tflApiKey,
+		weatherkitKeyId,
+		weatherkitPrivateKey,
+		weatherkitServiceId,
+		weatherkitTeamId,
+	}
+}
+
+function readRequiredEnv(
+	env: Record<string, string | undefined>,
+	name: string,
+	missing: string[],
+): string {
+	const value = readOptionalEnv(env, name)
+	if (!value) {
+		missing.push(name)
+	}
+	return value ?? ""
+}
+
+function readOptionalEnv(
+	env: Record<string, string | undefined>,
+	name: string,
+): string | undefined {
+	const value = env[name]?.trim()
+	return value ? value : undefined
+}

apps/freya-backend/src/location/http.ts

@@ -57,7 +57,7 @@ async function handleUpdateLocation(c: Context<Env>) {
 		return c.json({ error: "Service unavailable" }, 503)
 	}
 
-	await session.engine.executeAction("aelis.location", "update-location", {
+	await session.engine.executeAction("freya.location", "update-location", {
 		lat: result.lat,
 		lng: result.lng,
 		accuracy: result.accuracy,

apps/freya-backend/src/location/provider.ts

@@ -1,9 +1,9 @@
-import { LocationSource } from "@aelis/source-location"
+import { LocationSource } from "@freya/source-location"
 
 import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
 
 export class LocationSourceProvider implements FeedSourceProvider {
-	readonly sourceId = "aelis.location"
+	readonly sourceId = "freya.location"
 
 	async feedSourceForUser(
 		_userId: string,

apps/freya-backend/src/reminders/provider.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test"
+
+import type { Database } from "../db/index.ts"
+
+import { ReminderSourceProvider } from "./provider.ts"
+
+const fakeDb = {} as Database
+
+describe("ReminderSourceProvider", () => {
+	const provider = new ReminderSourceProvider({ db: fakeDb })
+
+	test("sourceId is freya.reminders", () => {
+		expect(provider.sourceId).toBe("freya.reminders")
+	})
+
+	test("throws when config has extra keys", async () => {
+		await expect(
+			provider.feedSourceForUser("user-1", { lookAheadMs: 1000, extra: true }, null),
+		).rejects.toThrow("Invalid reminders config")
+	})
+
+	test("throws when defaultTimeZone is invalid", async () => {
+		await expect(
+			provider.feedSourceForUser("user-1", { defaultTimeZone: "Not/AZone" }, null),
+		).rejects.toThrow("Invalid reminders config")
+	})
+
+	test("returns ReminderSource with valid config", async () => {
+		const source = await provider.feedSourceForUser(
+			"user-1",
+			{
+				lookAheadMs: 48 * 60 * 60 * 1000,
+				lookBackMs: 60 * 60 * 1000,
+				includeCompleted: true,
+				defaultTimeZone: "Europe/London",
+			},
+			null,
+		)
+
+		expect(source).toBeDefined()
+		expect(source.id).toBe("freya.reminders")
+	})
+
+	test("returns ReminderSource with empty config", async () => {
+		const source = await provider.feedSourceForUser("user-1", {}, null)
+
+		expect(source).toBeDefined()
+		expect(source.id).toBe("freya.reminders")
+	})
+})

apps/freya-backend/src/reminders/provider.ts

@@ -0,0 +1,48 @@
+import { ReminderSource, ReminderTimeZoneInput } from "@freya/source-reminders"
+import { type } from "arktype"
+
+import type { Database } from "../db/index.ts"
+import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
+
+import { DrizzleReminderStorage } from "./storage.ts"
+
+export interface ReminderSourceProviderOptions {
+	db: Database
+}
+
+export const reminderConfig = type({
+	"+": "reject",
+	"lookAheadMs?": "number.integer >= 0",
+	"lookBackMs?": "number.integer >= 0",
+	"includeCompleted?": "boolean",
+	"defaultTimeZone?": ReminderTimeZoneInput,
+})
+
+export class ReminderSourceProvider implements FeedSourceProvider {
+	readonly sourceId = "freya.reminders"
+	readonly configSchema = reminderConfig
+	private readonly db: Database
+
+	constructor(options: ReminderSourceProviderOptions) {
+		this.db = options.db
+	}
+
+	async feedSourceForUser(
+		userId: string,
+		config: unknown,
+		_credentials: unknown,
+	): Promise<ReminderSource> {
+		const parsed = reminderConfig(config)
+		if (parsed instanceof type.errors) {
+			throw new Error(`Invalid reminders config: ${parsed.summary}`)
+		}
+
+		return new ReminderSource({
+			storage: new DrizzleReminderStorage(this.db, userId),
+			lookAheadMs: parsed.lookAheadMs,
+			lookBackMs: parsed.lookBackMs,
+			includeCompleted: parsed.includeCompleted,
+			defaultTimeZone: parsed.defaultTimeZone,
+		})
+	}
+}

apps/freya-backend/src/reminders/storage.ts

@@ -0,0 +1,276 @@
+import type {
+	CreateReminderInput,
+	Reminder,
+	ReminderListParams,
+	ReminderOccurrenceOverride,
+	ReminderOccurrenceOverrideInput,
+	ReminderOccurrenceOverrideListParams,
+	ReminderOccurrencePatch,
+	ReminderPatch,
+	ReminderPriority,
+	ReminderRecurrence,
+	ReminderStorage,
+} from "@freya/source-reminders"
+
+import {
+	ReminderOccurrencePatchInput,
+	ReminderPriority as ReminderPriorityValue,
+	ReminderPriorityInput,
+	ReminderRecurrenceInput,
+} from "@freya/source-reminders"
+import { type } from "arktype"
+import { and, eq, inArray } from "drizzle-orm"
+
+import type { Database } from "../db/index.ts"
+
+import { reminderOccurrenceOverrides, reminders } from "../db/schema.ts"
+
+interface ArkSchema<T> {
+	(value: unknown): T | InstanceType<typeof type.errors>
+}
+
+type ReminderRow = typeof reminders.$inferSelect
+type ReminderInsert = typeof reminders.$inferInsert
+type ReminderOccurrenceOverrideRow = typeof reminderOccurrenceOverrides.$inferSelect
+type ReminderOccurrenceOverrideInsert = typeof reminderOccurrenceOverrides.$inferInsert
+
+export class DrizzleReminderStorage implements ReminderStorage {
+	private readonly db: Database
+	private readonly userId: string
+
+	constructor(db: Database, userId: string) {
+		this.db = db
+		this.userId = userId
+	}
+
+	async listReminders(_params: ReminderListParams): Promise<Reminder[]> {
+		const rows = await this.db.select().from(reminders).where(eq(reminders.userId, this.userId))
+
+		return rows.map(rowToReminder)
+	}
+
+	async getReminder(id: string): Promise<Reminder | null> {
+		const rows = await this.db
+			.select()
+			.from(reminders)
+			.where(and(eq(reminders.userId, this.userId), eq(reminders.id, id)))
+			.limit(1)
+
+		return rows[0] ? rowToReminder(rows[0]) : null
+	}
+
+	async createReminder(input: CreateReminderInput): Promise<Reminder> {
+		const rows = await this.db
+			.insert(reminders)
+			.values({
+				userId: this.userId,
+				title: input.title,
+				notes: input.notes ?? null,
+				dueAt: input.dueAt,
+				timeZone: input.timeZone ?? "UTC",
+				recurrence: serializeRecurrence(input.recurrence ?? null),
+				priority: input.priority ?? ReminderPriorityValue.Normal,
+			})
+			.returning()
+
+		return rowToReminder(requireRow(rows))
+	}
+
+	async updateReminder(id: string, patch: ReminderPatch): Promise<Reminder> {
+		const update: Partial<ReminderInsert> = { updatedAt: new Date() }
+
+		if (hasOwn(patch, "title")) update.title = patch.title
+		if (hasOwn(patch, "notes")) update.notes = patch.notes ?? null
+		if (hasOwn(patch, "dueAt")) update.dueAt = patch.dueAt
+		if (hasOwn(patch, "timeZone")) update.timeZone = patch.timeZone
+		if (hasOwn(patch, "recurrence")) update.recurrence = serializeRecurrence(patch.recurrence)
+		if (hasOwn(patch, "priority")) update.priority = patch.priority
+
+		const rows = await this.db
+			.update(reminders)
+			.set(update)
+			.where(and(eq(reminders.userId, this.userId), eq(reminders.id, id)))
+			.returning()
+
+		return rowToReminder(requireRow(rows, `Reminder not found: ${id}`))
+	}
+
+	async deleteReminder(id: string): Promise<void> {
+		await this.db
+			.delete(reminders)
+			.where(and(eq(reminders.userId, this.userId), eq(reminders.id, id)))
+	}
+
+	async listOccurrenceOverrides(
+		params: ReminderOccurrenceOverrideListParams,
+	): Promise<ReminderOccurrenceOverride[]> {
+		if (params.reminderIds.length === 0) return []
+
+		const rows = await this.db
+			.select()
+			.from(reminderOccurrenceOverrides)
+			.where(
+				and(
+					eq(reminderOccurrenceOverrides.userId, this.userId),
+					inArray(reminderOccurrenceOverrides.reminderId, [...params.reminderIds]),
+				),
+			)
+
+		return rows.map(rowToOccurrenceOverride)
+	}
+
+	async getOccurrenceOverride(
+		reminderId: string,
+		occurrenceId: string,
+	): Promise<ReminderOccurrenceOverride | null> {
+		const rows = await this.db
+			.select()
+			.from(reminderOccurrenceOverrides)
+			.where(
+				and(
+					eq(reminderOccurrenceOverrides.userId, this.userId),
+					eq(reminderOccurrenceOverrides.reminderId, reminderId),
+					eq(reminderOccurrenceOverrides.occurrenceId, occurrenceId),
+				),
+			)
+			.limit(1)
+
+		return rows[0] ? rowToOccurrenceOverride(rows[0]) : null
+	}
+
+	async upsertOccurrenceOverride(
+		input: ReminderOccurrenceOverrideInput,
+	): Promise<ReminderOccurrenceOverride> {
+		const values: ReminderOccurrenceOverrideInsert = {
+			userId: this.userId,
+			reminderId: input.reminderId,
+			occurrenceId: input.occurrenceId,
+			originalDueAt: input.originalDueAt,
+			patch: serializeOccurrencePatch(input.patch),
+			completedAt: input.completedAt ?? null,
+			deletedAt: input.deletedAt ?? null,
+		}
+
+		const rows = await this.db
+			.insert(reminderOccurrenceOverrides)
+			.values(values)
+			.onConflictDoUpdate({
+				target: [reminderOccurrenceOverrides.reminderId, reminderOccurrenceOverrides.occurrenceId],
+				set: {
+					originalDueAt: values.originalDueAt,
+					patch: values.patch,
+					completedAt: values.completedAt,
+					deletedAt: values.deletedAt,
+					updatedAt: new Date(),
+				},
+			})
+			.returning()
+
+		return rowToOccurrenceOverride(requireRow(rows))
+	}
+
+	async deleteOccurrenceOverride(reminderId: string, occurrenceId: string): Promise<void> {
+		await this.db
+			.delete(reminderOccurrenceOverrides)
+			.where(
+				and(
+					eq(reminderOccurrenceOverrides.userId, this.userId),
+					eq(reminderOccurrenceOverrides.reminderId, reminderId),
+					eq(reminderOccurrenceOverrides.occurrenceId, occurrenceId),
+				),
+			)
+	}
+}
+
+function rowToReminder(row: ReminderRow): Reminder {
+	return {
+		id: row.id,
+		title: row.title,
+		notes: row.notes,
+		dueAt: row.dueAt,
+		timeZone: row.timeZone,
+		recurrence: parseRecurrence(row.recurrence),
+		priority: assertSchema<ReminderPriority>(ReminderPriorityInput, row.priority),
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	}
+}
+
+function rowToOccurrenceOverride(row: ReminderOccurrenceOverrideRow): ReminderOccurrenceOverride {
+	return {
+		reminderId: row.reminderId,
+		occurrenceId: row.occurrenceId,
+		originalDueAt: row.originalDueAt,
+		patch: parseOccurrencePatch(row.patch),
+		completedAt: row.completedAt,
+		deletedAt: row.deletedAt,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt,
+	}
+}
+
+function parseRecurrence(value: unknown): ReminderRecurrence | null {
+	if (value === null || value === undefined) return null
+	return assertSchema<ReminderRecurrence>(ReminderRecurrenceInput, value)
+}
+
+function parseOccurrencePatch(value: unknown): ReminderOccurrencePatch | undefined {
+	if (value === null || value === undefined) return undefined
+	return assertSchema<ReminderOccurrencePatch>(ReminderOccurrencePatchInput, value)
+}
+
+function serializeRecurrence(recurrence: ReminderRecurrence | null | undefined): unknown {
+	if (!recurrence) return null
+
+	const value: Record<string, unknown> = {
+		frequency: recurrence.frequency,
+		interval: recurrence.interval,
+	}
+
+	if (recurrence.weekdays !== undefined) value.weekdays = recurrence.weekdays
+	if (recurrence.count !== undefined) value.count = recurrence.count
+	if (recurrence.until !== undefined) value.until = recurrence.until.toISOString()
+
+	return value
+}
+
+function serializeOccurrencePatch(patch: ReminderOccurrencePatch | undefined): unknown {
+	if (!patch) return null
+
+	const value: Record<string, unknown> = {}
+	if (hasOwn(patch, "title")) value.title = patch.title
+	if (hasOwn(patch, "notes")) value.notes = patch.notes
+	if (hasOwn(patch, "dueAt") && patch.dueAt !== undefined) {
+		value.dueAt = patch.dueAt.toISOString()
+	}
+	if (hasOwn(patch, "timeZone")) value.timeZone = patch.timeZone
+	if (hasOwn(patch, "priority")) value.priority = patch.priority
+
+	return value
+}
+
+function requireRow<TRow>(
+	rows: TRow[],
+	message = "Reminder storage mutation returned no rows",
+): TRow {
+	const row = rows[0]
+	if (!row) {
+		throw new Error(message)
+	}
+	return row
+}
+
+function assertSchema<T>(schema: ArkSchema<T>, value: unknown): T {
+	const result = schema(value)
+	if (result instanceof type.errors) {
+		throw new Error(result.summary)
+	}
+	return result
+}
+
+function hasOwn<TObject extends object, TKey extends PropertyKey>(
+	object: TObject,
+	key: TKey,
+): object is TObject & Record<TKey, unknown> {
+	return Object.prototype.hasOwnProperty.call(object, key)
+}

apps/freya-backend/src/server.ts

@@ -11,55 +11,52 @@ import { createDatabase } from "./db/index.ts"
 import { registerFeedHttpHandlers } from "./engine/http.ts"
 import { createFeedEnhancer } from "./enhancement/enhance-feed.ts"
 import { createLlmClient } from "./enhancement/llm-client.ts"
+import { GoogleMapsSourceProvider } from "./google-maps/provider.ts"
 import { CredentialEncryptor } from "./lib/crypto.ts"
+import { ensureEnv } from "./lib/env.ts"
 import { registerLocationHttpHandlers } from "./location/http.ts"
 import { LocationSourceProvider } from "./location/provider.ts"
+import { ReminderSourceProvider } from "./reminders/provider.ts"
 import { UserSessionManager } from "./session/index.ts"
 import { registerSourcesHttpHandlers } from "./sources/http.ts"
 import { TflSourceProvider } from "./tfl/provider.ts"
 import { WeatherSourceProvider } from "./weather/provider.ts"
+import { WebSearchSourceProvider } from "./web-search/provider.ts"
 
 function main() {
-	const { db, close: closeDb } = createDatabase(process.env.DATABASE_URL!)
+	const env = ensureEnv(process.env)
+
+	const { db, close: closeDb } = createDatabase(env.databaseUrl)
 	const auth = createAuth(db)
 
-	const openrouterApiKey = process.env.OPENROUTER_API_KEY
-	const feedEnhancer = openrouterApiKey
-		? createFeedEnhancer({
-				client: createLlmClient({
-					apiKey: openrouterApiKey,
-					model: process.env.OPENROUTER_MODEL || undefined,
-				}),
-			})
-		: null
-	if (!feedEnhancer) {
-		console.warn("[enhancement] OPENROUTER_API_KEY not set — feed enhancement disabled")
-	}
+	const feedEnhancer = createFeedEnhancer({
+		client: createLlmClient({
+			apiKey: env.openrouterApiKey,
+			model: env.openrouterModel,
+		}),
+	})
 
-	const credentialEncryptionKey = process.env.CREDENTIAL_ENCRYPTION_KEY
-	const credentialEncryptor = credentialEncryptionKey
-		? new CredentialEncryptor(credentialEncryptionKey)
-		: null
-	if (!credentialEncryptor) {
-		console.warn(
-			"[credentials] CREDENTIAL_ENCRYPTION_KEY not set — per-user credential storage disabled",
-		)
-	}
+	const credentialEncryptor = new CredentialEncryptor(env.credentialEncryptionKey)
 
 	const sessionManager = new UserSessionManager({
 		db,
 		providers: [
 			new CalDavSourceProvider(),
 			new LocationSourceProvider(),
+			new ReminderSourceProvider({ db }),
 			new WeatherSourceProvider({
 				credentials: {
-					privateKey: process.env.WEATHERKIT_PRIVATE_KEY!,
-					keyId: process.env.WEATHERKIT_KEY_ID!,
-					teamId: process.env.WEATHERKIT_TEAM_ID!,
-					serviceId: process.env.WEATHERKIT_SERVICE_ID!,
+					privateKey: env.weatherkitPrivateKey,
+					keyId: env.weatherkitKeyId,
+					teamId: env.weatherkitTeamId,
+					serviceId: env.weatherkitServiceId,
 				},
 			}),
-			new TflSourceProvider({ apiKey: process.env.TFL_API_KEY! }),
+			new TflSourceProvider({ apiKey: env.tflApiKey }),
+			new WebSearchSourceProvider({ apiKey: env.exaApiKey }),
+			new GoogleMapsSourceProvider({
+				apiKey: env.googleMapsApiKey,
+			}),
 		],
 		feedEnhancer,
 		credentialEncryptor,
@@ -122,5 +119,6 @@ const app = main()
 
 export default {
 	port: 3000,
+	hostname: "0.0.0.0",
 	fetch: app.fetch,
 }

apps/freya-backend/src/session/feed-source-provider.ts

@@ -1,10 +1,10 @@
-import type { FeedSource } from "@aelis/core"
+import type { FeedSource } from "@freya/core"
 import type { type } from "arktype"
 
 export type ConfigSchema = ReturnType<typeof type>
 
 export interface FeedSourceProvider {
-	/** The source ID this provider is responsible for (e.g., "aelis.location"). */
+	/** The source ID this provider is responsible for (e.g., "freya.location"). */
 	readonly sourceId: string
 	/** Arktype schema for validating user-provided config. Omit if the source has no config. */
 	readonly configSchema?: ConfigSchema

apps/freya-backend/src/session/user-session-manager.test.ts

@@ -1,7 +1,7 @@
-import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@freya/core"
 
-import { LocationSource } from "@aelis/source-location"
-import { WeatherSource } from "@aelis/source-weatherkit"
+import { LocationSource } from "@freya/source-location"
+import { WeatherSource } from "@freya/source-weatherkit"
 import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test"
 
 import type { Database } from "../db/index.ts"
@@ -44,15 +44,6 @@ function getEnabledSourceIds(userId: string): string[] {
  */
 let mockFindResult: unknown | undefined
 
-/**
- * Spy for `upsertConfig` calls. Tests can inspect calls via
- * `mockUpsertConfigCalls`.
- */
-const mockUpsertConfigCalls: Array<{
-	sourceId: string
-	data: { enabled: boolean; config: unknown }
-}> = []
-
 /**
  * Spy for `updateCredentials` calls. Tests can inspect calls via
  * `mockUpdateCredentialsCalls` or override behavior.
@@ -90,8 +81,26 @@ mock.module("../sources/user-sources.ts", () => ({
 				updatedAt: now,
 			}
 		},
-		async upsertConfig(sourceId: string, data: { enabled: boolean; config: unknown }) {
-			mockUpsertConfigCalls.push({ sourceId, data })
+		async findForUpdate(sourceId: string) {
+			// Delegates to find — row locking is a no-op in tests.
+			if (mockFindResult !== undefined) return mockFindResult
+			const now = new Date()
+			return {
+				id: crypto.randomUUID(),
+				userId,
+				sourceId,
+				enabled: true,
+				config: {},
+				credentials: null,
+				createdAt: now,
+				updatedAt: now,
+			}
+		},
+		async updateConfig(_sourceId: string, _update: { enabled?: boolean; config?: unknown }) {
+			// no-op for tests
+		},
+		async upsertConfig(_sourceId: string, _data: { enabled: boolean; config: unknown }) {
+			// no-op for tests
 		},
 		async updateCredentials(sourceId: string, credentials: Buffer) {
 			if (mockUpdateCredentialsError) {
@@ -102,7 +111,9 @@ mock.module("../sources/user-sources.ts", () => ({
 	}),
 }))
 
-const fakeDb = {} as Database
+const fakeDb = {
+	transaction: <T>(fn: (tx: unknown) => Promise<T>) => fn(fakeDb),
+} as unknown as Database
 
 function createStubSource(id: string, items: FeedItem[] = []): FeedSource {
 	return {
@@ -134,14 +145,14 @@ function createStubProvider(
 }
 
 const locationProvider: FeedSourceProvider = {
-	sourceId: "aelis.location",
+	sourceId: "freya.location",
 	async feedSourceForUser() {
 		return new LocationSource()
 	},
 }
 
 const weatherProvider: FeedSourceProvider = {
-	sourceId: "aelis.weather",
+	sourceId: "freya.weather",
 	async feedSourceForUser() {
 		return new WeatherSource({ client: { fetch: async () => ({}) as never } })
 	},
@@ -150,14 +161,13 @@ const weatherProvider: FeedSourceProvider = {
 beforeEach(() => {
 	enabledByUser.clear()
 	mockFindResult = undefined
-	mockUpsertConfigCalls.length = 0
 	mockUpdateCredentialsCalls.length = 0
 	mockUpdateCredentialsError = null
 })
 
 describe("UserSessionManager", () => {
 	test("getOrCreate creates session on first call", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		const session = await manager.getOrCreate("user-1")
@@ -167,7 +177,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("getOrCreate returns same session for same user", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		const session1 = await manager.getOrCreate("user-1")
@@ -177,7 +187,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("getOrCreate returns different sessions for different users", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		const session1 = await manager.getOrCreate("user-1")
@@ -187,20 +197,20 @@ describe("UserSessionManager", () => {
 	})
 
 	test("each user gets independent source instances", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		const session1 = await manager.getOrCreate("user-1")
 		const session2 = await manager.getOrCreate("user-2")
 
-		const source1 = session1.getSource<LocationSource>("aelis.location")
-		const source2 = session2.getSource<LocationSource>("aelis.location")
+		const source1 = session1.getSource<LocationSource>("freya.location")
+		const source2 = session2.getSource<LocationSource>("freya.location")
 
 		expect(source1).not.toBe(source2)
 	})
 
 	test("remove destroys session and allows re-creation", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		const session1 = await manager.getOrCreate("user-1")
@@ -211,14 +221,14 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove is no-op for unknown user", () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		expect(() => manager.remove("unknown")).not.toThrow()
 	})
 
 	test("registers multiple providers", async () => {
-		setEnabledSources(["aelis.location", "aelis.weather"])
+		setEnabledSources(["freya.location", "freya.weather"])
 		const manager = new UserSessionManager({
 			db: fakeDb,
 			providers: [locationProvider, weatherProvider],
@@ -226,12 +236,12 @@ describe("UserSessionManager", () => {
 
 		const session = await manager.getOrCreate("user-1")
 
-		expect(session.getSource("aelis.location")).toBeDefined()
-		expect(session.getSource("aelis.weather")).toBeDefined()
+		expect(session.getSource("freya.location")).toBeDefined()
+		expect(session.getSource("freya.weather")).toBeDefined()
 	})
 
 	test("refresh returns feed result through session", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		const session = await manager.getOrCreate("user-1")
@@ -244,30 +254,30 @@ describe("UserSessionManager", () => {
 	})
 
 	test("location update via executeAction works", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
 		const session = await manager.getOrCreate("user-1")
-		await session.engine.executeAction("aelis.location", "update-location", {
+		await session.engine.executeAction("freya.location", "update-location", {
 			lat: 51.5074,
 			lng: -0.1278,
 			accuracy: 10,
 			timestamp: new Date(),
 		})
 
-		const source = session.getSource<LocationSource>("aelis.location")
+		const source = session.getSource<LocationSource>("freya.location")
 		expect(source?.lastLocation?.lat).toBe(51.5074)
 	})
 
 	test("subscribe receives updates after location push", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 		const callback = mock()
 
 		const session = await manager.getOrCreate("user-1")
 		session.engine.subscribe(callback)
 
-		await session.engine.executeAction("aelis.location", "update-location", {
+		await session.engine.executeAction("freya.location", "update-location", {
 			lat: 51.5074,
 			lng: -0.1278,
 			accuracy: 10,
@@ -281,7 +291,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove stops reactive updates", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 		const callback = mock()
 
@@ -292,7 +302,7 @@ describe("UserSessionManager", () => {
 
 		// Create new session and push location — old callback should not fire
 		const session2 = await manager.getOrCreate("user-1")
-		await session2.engine.executeAction("aelis.location", "update-location", {
+		await session2.engine.executeAction("freya.location", "update-location", {
 			lat: 51.5074,
 			lng: -0.1278,
 			accuracy: 10,
@@ -305,9 +315,9 @@ describe("UserSessionManager", () => {
 	})
 
 	test("creates session with successful providers when some fail", async () => {
-		setEnabledSources(["aelis.location", "aelis.failing"])
+		setEnabledSources(["freya.location", "freya.failing"])
 		const failingProvider: FeedSourceProvider = {
-			sourceId: "aelis.failing",
+			sourceId: "freya.failing",
 			async feedSourceForUser() {
 				throw new Error("provider failed")
 			},
@@ -323,25 +333,25 @@ describe("UserSessionManager", () => {
 		const session = await manager.getOrCreate("user-1")
 
 		expect(session).toBeDefined()
-		expect(session.getSource("aelis.location")).toBeDefined()
+		expect(session.getSource("freya.location")).toBeDefined()
 		expect(spy).toHaveBeenCalled()
 
 		spy.mockRestore()
 	})
 
 	test("throws AggregateError when all providers fail", async () => {
-		setEnabledSources(["aelis.fail-1", "aelis.fail-2"])
+		setEnabledSources(["freya.fail-1", "freya.fail-2"])
 		const manager = new UserSessionManager({
 			db: fakeDb,
 			providers: [
 				{
-					sourceId: "aelis.fail-1",
+					sourceId: "freya.fail-1",
 					async feedSourceForUser() {
 						throw new Error("first failed")
 					},
 				},
 				{
-					sourceId: "aelis.fail-2",
+					sourceId: "freya.fail-2",
 					async feedSourceForUser() {
 						throw new Error("second failed")
 					},
@@ -353,13 +363,13 @@ describe("UserSessionManager", () => {
 	})
 
 	test("concurrent getOrCreate for same user returns same session", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		let callCount = 0
 		const manager = new UserSessionManager({
 			db: fakeDb,
 			providers: [
 				{
-					sourceId: "aelis.location",
+					sourceId: "freya.location",
 					async feedSourceForUser() {
 						callCount++
 						await new Promise((resolve) => setTimeout(resolve, 10))
@@ -379,7 +389,7 @@ describe("UserSessionManager", () => {
 	})
 
 	test("remove during in-flight getOrCreate prevents session from being stored", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		let resolveProvider: () => void
 		const providerGate = new Promise<void>((r) => {
 			resolveProvider = r
@@ -389,7 +399,7 @@ describe("UserSessionManager", () => {
 			db: fakeDb,
 			providers: [
 				{
-					sourceId: "aelis.location",
+					sourceId: "freya.location",
 					async feedSourceForUser() {
 						await providerGate
 						return new LocationSource()
@@ -415,15 +425,15 @@ describe("UserSessionManager", () => {
 	})
 
 	test("only invokes providers for sources enabled for the user", async () => {
-		setEnabledSources(["aelis.location"])
-		const locationFactory = mock(async () => createStubSource("aelis.location"))
-		const weatherFactory = mock(async () => createStubSource("aelis.weather"))
+		setEnabledSources(["freya.location"])
+		const locationFactory = mock(async () => createStubSource("freya.location"))
+		const weatherFactory = mock(async () => createStubSource("freya.weather"))
 
 		const manager = new UserSessionManager({
 			db: fakeDb,
 			providers: [
-				{ sourceId: "aelis.location", feedSourceForUser: locationFactory },
-				{ sourceId: "aelis.weather", feedSourceForUser: weatherFactory },
+				{ sourceId: "freya.location", feedSourceForUser: locationFactory },
+				{ sourceId: "freya.weather", feedSourceForUser: weatherFactory },
 			],
 		})
 
@@ -431,43 +441,43 @@ describe("UserSessionManager", () => {
 
 		expect(locationFactory).toHaveBeenCalledTimes(1)
 		expect(weatherFactory).not.toHaveBeenCalled()
-		expect(session.getSource("aelis.location")).toBeDefined()
-		expect(session.getSource("aelis.weather")).toBeUndefined()
+		expect(session.getSource("freya.location")).toBeDefined()
+		expect(session.getSource("freya.weather")).toBeUndefined()
 	})
 
 	test("creates empty session when no sources are enabled", async () => {
 		setEnabledSources([])
-		const factory = mock(async () => createStubSource("aelis.location"))
+		const factory = mock(async () => createStubSource("freya.location"))
 
 		const manager = new UserSessionManager({
 			db: fakeDb,
-			providers: [{ sourceId: "aelis.location", feedSourceForUser: factory }],
+			providers: [{ sourceId: "freya.location", feedSourceForUser: factory }],
 		})
 
 		const session = await manager.getOrCreate("user-1")
 
 		expect(factory).not.toHaveBeenCalled()
 		expect(session).toBeDefined()
-		expect(session.getSource("aelis.location")).toBeUndefined()
+		expect(session.getSource("freya.location")).toBeUndefined()
 	})
 
 	test("per-user enabled sources are respected", async () => {
 		enabledByUser.clear()
-		setEnabledSourcesForUser("user-1", ["aelis.location"])
-		setEnabledSourcesForUser("user-2", ["aelis.weather"])
+		setEnabledSourcesForUser("user-1", ["freya.location"])
+		setEnabledSourcesForUser("user-2", ["freya.weather"])
 
 		const manager = new UserSessionManager({
 			db: fakeDb,
-			providers: [createStubProvider("aelis.location"), createStubProvider("aelis.weather")],
+			providers: [createStubProvider("freya.location"), createStubProvider("freya.weather")],
 		})
 
 		const session1 = await manager.getOrCreate("user-1")
 		const session2 = await manager.getOrCreate("user-2")
 
-		expect(session1.getSource("aelis.location")).toBeDefined()
-		expect(session1.getSource("aelis.weather")).toBeUndefined()
-		expect(session2.getSource("aelis.location")).toBeUndefined()
-		expect(session2.getSource("aelis.weather")).toBeDefined()
+		expect(session1.getSource("freya.location")).toBeDefined()
+		expect(session1.getSource("freya.weather")).toBeUndefined()
+		expect(session2.getSource("freya.location")).toBeUndefined()
+		expect(session2.getSource("freya.weather")).toBeDefined()
 	})
 })
 
@@ -515,10 +525,10 @@ describe("UserSessionManager.replaceProvider", () => {
 	})
 
 	test("throws for unknown provider sourceId", async () => {
-		setEnabledSources(["aelis.location"])
+		setEnabledSources(["freya.location"])
 		const manager = new UserSessionManager({ db: fakeDb, providers: [locationProvider] })
 
-		const unknownProvider = createStubProvider("aelis.unknown")
+		const unknownProvider = createStubProvider("freya.unknown")
 
 		await expect(manager.replaceProvider(unknownProvider)).rejects.toThrow(
 			"no existing provider with that sourceId",
@@ -838,64 +848,120 @@ describe("UserSessionManager.updateSourceCredentials", () => {
 	})
 })
 
-describe("UserSessionManager.upsertSourceConfig", () => {
-	test("persists config to DB even when feedSourceForUser throws", async () => {
-		setEnabledSources(["test"])
-		let callCount = 0
-		const factory = mock(async (_userId: string, _config: unknown, _credentials: unknown) => {
-			callCount++
-			// Succeed on first call (session creation), throw on second (upsert refresh)
-			if (callCount > 1) {
-				throw new InvalidSourceCredentialsError("test", "credentials required")
-			}
-			return createStubSource("test")
-		})
-		const provider: FeedSourceProvider = { sourceId: "test", feedSourceForUser: factory }
-		const manager = new UserSessionManager({ db: fakeDb, providers: [provider] })
-
-		// Create a session so the session-refresh path is exercised
-		await manager.getOrCreate("user-1")
-
-		const spy = spyOn(console, "warn").mockImplementation(() => {})
-
-		// upsertSourceConfig with no existing credentials — provider will throw
-		await manager.upsertSourceConfig("user-1", "test", {
-			enabled: true,
-			config: { url: "https://example.com" },
-		})
-
-		// Config should still have been persisted to DB
-		expect(mockUpsertConfigCalls).toHaveLength(1)
-		expect(mockUpsertConfigCalls[0]!.sourceId).toBe("test")
-		expect(mockUpsertConfigCalls[0]!.data.enabled).toBe(true)
-
-		// The error should have been logged, not thrown
-		expect(spy).toHaveBeenCalled()
-
-		spy.mockRestore()
-	})
-
-	test("adds source to session when feedSourceForUser succeeds", async () => {
+describe("UserSessionManager.saveSourceConfig", () => {
+	test("upserts config without credentials (existing behavior)", async () => {
 		setEnabledSources(["test"])
 		const factory = mock(async () => createStubSource("test"))
 		const provider: FeedSourceProvider = { sourceId: "test", feedSourceForUser: factory }
-		const manager = new UserSessionManager({ db: fakeDb, providers: [provider] })
+		const manager = new UserSessionManager({
+			db: fakeDb,
+			providers: [provider],
+			credentialEncryptor: testEncryptor,
+		})
+
+		// Create a session first so we can verify the source is refreshed
+		await manager.getOrCreate("user-1")
+
+		await manager.saveSourceConfig("user-1", "test", {
+			enabled: true,
+			config: { key: "value" },
+		})
+
+		// feedSourceForUser called once for session creation, once for upsert refresh
+		expect(factory).toHaveBeenCalledTimes(2)
+		// No credentials should have been persisted
+		expect(mockUpdateCredentialsCalls).toHaveLength(0)
+	})
+
+	test("upserts config with credentials — persists both and passes credentials to source", async () => {
+		setEnabledSources(["test"])
+		let receivedCredentials: unknown = null
+		const factory = mock(async (_userId: string, _config: unknown, creds: unknown) => {
+			receivedCredentials = creds
+			return createStubSource("test")
+		})
+		const provider: FeedSourceProvider = { sourceId: "test", feedSourceForUser: factory }
+		const manager = new UserSessionManager({
+			db: fakeDb,
+			providers: [provider],
+			credentialEncryptor: testEncryptor,
+		})
+
+		// Create a session so the source refresh path runs
+		await manager.getOrCreate("user-1")
+
+		const creds = { username: "alice", password: "s3cret" }
+		await manager.saveSourceConfig("user-1", "test", {
+			enabled: true,
+			config: { serverUrl: "https://example.com" },
+			credentials: creds,
+		})
+
+		// Credentials were encrypted and persisted
+		expect(mockUpdateCredentialsCalls).toHaveLength(1)
+		const decrypted = JSON.parse(testEncryptor.decrypt(mockUpdateCredentialsCalls[0]!.credentials))
+		expect(decrypted).toEqual(creds)
+
+		// feedSourceForUser received the provided credentials (not null)
+		expect(receivedCredentials).toEqual(creds)
+	})
+
+	test("upserts config with credentials adds source to session when not already present", async () => {
+		// Start with no enabled sources so the session is empty
+		setEnabledSources([])
+		const factory = mock(async () => createStubSource("test"))
+		const provider: FeedSourceProvider = { sourceId: "test", feedSourceForUser: factory }
+		const manager = new UserSessionManager({
+			db: fakeDb,
+			providers: [provider],
+			credentialEncryptor: testEncryptor,
+		})
 
 		const session = await manager.getOrCreate("user-1")
-		await manager.upsertSourceConfig("user-1", "test", { enabled: true })
+		expect(session.hasSource("test")).toBe(false)
 
-		// Config persisted
-		expect(mockUpsertConfigCalls).toHaveLength(1)
-		// Source should be in the session (feedSourceForUser succeeded)
-		expect(session.getSource("test")).toBeDefined()
+		// Set mockFindResult to undefined so find() returns a row (simulating the row was just created by upsertConfig)
+		await manager.saveSourceConfig("user-1", "test", {
+			enabled: true,
+			config: {},
+			credentials: { token: "abc" },
+		})
+
+		// Source should now be in the session
+		expect(session.hasSource("test")).toBe(true)
+		expect(mockUpdateCredentialsCalls).toHaveLength(1)
+	})
+
+	test("throws CredentialStorageUnavailableError when credentials provided without encryptor", async () => {
+		setEnabledSources(["test"])
+		const provider = createStubProvider("test")
+		const manager = new UserSessionManager({
+			db: fakeDb,
+			providers: [provider],
+			// No credentialEncryptor
+		})
+
+		await expect(
+			manager.saveSourceConfig("user-1", "test", {
+				enabled: true,
+				config: {},
+				credentials: { token: "abc" },
+			}),
+		).rejects.toBeInstanceOf(CredentialStorageUnavailableError)
 	})
 
 	test("throws SourceNotFoundError for unknown provider", async () => {
-		setEnabledSources([])
-		const manager = new UserSessionManager({ db: fakeDb, providers: [] })
+		const manager = new UserSessionManager({
+			db: fakeDb,
+			providers: [],
+			credentialEncryptor: testEncryptor,
+		})
 
 		await expect(
-			manager.upsertSourceConfig("user-1", "unknown", { enabled: true }),
+			manager.saveSourceConfig("user-1", "unknown", {
+				enabled: true,
+				config: {},
+			}),
 		).rejects.toBeInstanceOf(SourceNotFoundError)
 	})
 })

apps/freya-backend/src/session/user-session-manager.ts

@@ -1,4 +1,4 @@
-import type { FeedSource } from "@aelis/core"
+import type { FeedSource } from "@freya/core"
 
 import { type } from "arktype"
 import merge from "lodash.merge"
@@ -126,27 +126,29 @@ export class UserSessionManager {
 			return
 		}
 
-		// Fetch the existing row for config merging and credential access.
-		// NOTE: find + updateConfig is not atomic. A concurrent update could
-		// read stale config. Use SELECT FOR UPDATE or atomic jsonb merge if
-		// this becomes a problem.
-		const existingRow = await sources(this.db, userId).find(sourceId)
+		// Use a transaction with SELECT FOR UPDATE to prevent lost updates
+		// when concurrent PATCH requests merge config against the same base.
+		const { existingRow, mergedConfig } = await this.db.transaction(async (tx) => {
+			const existingRow = await sources(tx, userId).findForUpdate(sourceId)
 
-		let mergedConfig: Record<string, unknown> | undefined
-		if (update.config !== undefined && provider.configSchema) {
-			const existingConfig = (existingRow?.config ?? {}) as Record<string, unknown>
-			mergedConfig = merge({}, existingConfig, update.config)
+			let mergedConfig: Record<string, unknown> | undefined
+			if (update.config !== undefined && provider.configSchema) {
+				const existingConfig = (existingRow?.config ?? {}) as Record<string, unknown>
+				mergedConfig = merge({}, existingConfig, update.config)
 
-			const validated = provider.configSchema(mergedConfig)
-			if (validated instanceof type.errors) {
-				throw new InvalidSourceConfigError(sourceId, validated.summary)
+				const validated = provider.configSchema(mergedConfig)
+				if (validated instanceof type.errors) {
+					throw new InvalidSourceConfigError(sourceId, validated.summary)
+				}
 			}
-		}
 
-		// Throws SourceNotFoundError if the row doesn't exist
-		await sources(this.db, userId).updateConfig(sourceId, {
-			enabled: update.enabled,
-			config: mergedConfig,
+			// Throws SourceNotFoundError if the row doesn't exist
+			await sources(tx, userId).updateConfig(sourceId, {
+				enabled: update.enabled,
+				config: mergedConfig,
+			})
+
+			return { existingRow, mergedConfig }
 		})
 
 		// Refresh the specific source in the active session instead of
@@ -171,13 +173,18 @@ export class UserSessionManager {
 	 * inserts a new row if one doesn't exist and fully replaces config
 	 * (no merge).
 	 *
+	 * When `credentials` is provided, they are encrypted and persisted
+	 * alongside the config in the same flow, avoiding the race condition
+	 * of separate config + credential requests.
+	 *
 	 * @throws {SourceNotFoundError} if the sourceId has no registered provider
 	 * @throws {InvalidSourceConfigError} if config fails schema validation
+	 * @throws {CredentialStorageUnavailableError} if credentials are provided but no encryptor is configured
 	 */
-	async upsertSourceConfig(
+	async saveSourceConfig(
 		userId: string,
 		sourceId: string,
-		data: { enabled: boolean; config?: unknown },
+		data: { enabled: boolean; config?: unknown; credentials?: unknown },
 	): Promise<void> {
 		const provider = this.providers.get(sourceId)
 		if (!provider) {
@@ -191,15 +198,28 @@ export class UserSessionManager {
 			}
 		}
 
+		if (data.credentials !== undefined && !this.encryptor) {
+			throw new CredentialStorageUnavailableError()
+		}
+
 		const config = data.config ?? {}
 
-		// Fetch existing row before upsert to capture credentials for session refresh.
-		// For new rows this will be undefined — credentials will be null.
-		const existingRow = await sources(this.db, userId).find(sourceId)
+		// Run the upsert + credential update atomically so a failure in
+		// either step doesn't leave the row in an inconsistent state.
+		const existingRow = await this.db.transaction(async (tx) => {
+			const existing = await sources(tx, userId).find(sourceId)
 
-		await sources(this.db, userId).upsertConfig(sourceId, {
-			enabled: data.enabled,
-			config,
+			await sources(tx, userId).upsertConfig(sourceId, {
+				enabled: data.enabled,
+				config,
+			})
+
+			if (data.credentials !== undefined && this.encryptor) {
+				const encrypted = this.encryptor.encrypt(JSON.stringify(data.credentials))
+				await sources(tx, userId).updateCredentials(sourceId, encrypted)
+			}
+
+			return existing
 		})
 
 		const session = this.sessions.get(userId)
@@ -207,25 +227,18 @@ export class UserSessionManager {
 			if (!data.enabled) {
 				session.removeSource(sourceId)
 			} else {
-				const credentials = existingRow?.credentials
-					? this.decryptCredentials(existingRow.credentials)
-					: null
-				try {
-					const source = await provider.feedSourceForUser(userId, config, credentials)
-					if (session.hasSource(sourceId)) {
-						session.replaceSource(sourceId, source)
-					} else {
-						session.addSource(source)
-					}
-				} catch (err) {
-					// Provider may fail when credentials are not yet available (e.g. new
-					// source added before updateSourceCredentials is called). The config
-					// is already persisted above; updateSourceCredentials will add the
-					// source to the session later.
-					console.warn(
-						`[UserSessionManager] feedSourceForUser("${sourceId}") failed during upsert for user ${userId}, skipping session update:`,
-						err,
-					)
+				// Prefer the just-provided credentials over what was in the DB.
+				let credentials: unknown = null
+				if (data.credentials !== undefined) {
+					credentials = data.credentials
+				} else if (existingRow?.credentials) {
+					credentials = this.decryptCredentials(existingRow.credentials)
+				}
+				const source = await provider.feedSourceForUser(userId, config, credentials)
+				if (session.hasSource(sourceId)) {
+					session.replaceSource(sourceId, source)
+				} else {
+					session.addSource(source)
 				}
 			}
 		}

apps/freya-backend/src/session/user-session.test.ts

@@ -1,6 +1,6 @@
-import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@freya/core"
 
-import { LocationSource } from "@aelis/source-location"
+import { LocationSource } from "@freya/source-location"
 import { describe, expect, spyOn, test } from "bun:test"
 
 import { UserSession } from "./user-session.ts"
@@ -39,7 +39,7 @@ describe("UserSession", () => {
 		const location = new LocationSource()
 		const session = new UserSession("test-user", [location])
 
-		const result = session.getSource<LocationSource>("aelis.location")
+		const result = session.getSource<LocationSource>("freya.location")
 
 		expect(result).toBe(location)
 	})
@@ -62,7 +62,7 @@ describe("UserSession", () => {
 		const location = new LocationSource()
 		const session = new UserSession("test-user", [location])
 
-		await session.engine.executeAction("aelis.location", "update-location", {
+		await session.engine.executeAction("freya.location", "update-location", {
 			lat: 51.5,
 			lng: -0.1,
 			accuracy: 10,

apps/freya-backend/src/session/user-session.ts

@@ -1,4 +1,4 @@
-import { FeedEngine, type FeedItem, type FeedResult, type FeedSource } from "@aelis/core"
+import { FeedEngine, type FeedItem, type FeedResult, type FeedSource } from "@freya/core"
 
 import type { FeedEnhancer } from "../enhancement/enhance-feed.ts"
 

apps/freya-backend/src/sources/http.test.ts

@@ -1,4 +1,4 @@
-import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@aelis/core"
+import type { ActionDefinition, ContextEntry, FeedItem, FeedSource } from "@freya/core"
 
 import { describe, expect, mock, spyOn, test } from "bun:test"
 import { Hono } from "hono"
@@ -80,6 +80,9 @@ function createInMemoryStore() {
 				async find(sourceId: string) {
 					return rows.get(key(userId, sourceId))
 				},
+				async findForUpdate(sourceId: string) {
+					return rows.get(key(userId, sourceId))
+				},
 				async updateConfig(sourceId: string, update: { enabled?: boolean; config?: unknown }) {
 					const existing = rows.get(key(userId, sourceId))
 					if (!existing) {
@@ -125,7 +128,9 @@ mock.module("../sources/user-sources.ts", () => ({
 	},
 }))
 
-const fakeDb = {} as Database
+const fakeDb = {
+	transaction: <T>(fn: (tx: unknown) => Promise<T>) => fn(fakeDb),
+} as unknown as Database
 
 function createApp(providers: FeedSourceProvider[], userId?: string) {
 	const sessionManager = new UserSessionManager({ providers, db: fakeDb })
@@ -181,6 +186,18 @@ function put(app: Hono, sourceId: string, body: unknown) {
 	})
 }
 
+function listActions(app: Hono, sourceId: string) {
+	return app.request(`/api/sources/${sourceId}/actions`, { method: "GET" })
+}
+
+function executeAction(app: Hono, sourceId: string, actionId: string, body: unknown) {
+	return app.request(`/api/sources/${sourceId}/actions/${actionId}`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify(body),
+	})
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -188,16 +205,16 @@ function put(app: Hono, sourceId: string, body: unknown) {
 describe("GET /api/sources/:sourceId", () => {
 	test("returns 401 without auth", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)])
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)])
 
-		const res = await get(app, "aelis.weather")
+		const res = await get(app, "freya.weather")
 
 		expect(res.status).toBe(401)
 	})
 
 	test("returns 404 for unknown source", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
 		const res = await get(app, "unknown.source")
 
@@ -208,13 +225,13 @@ describe("GET /api/sources/:sourceId", () => {
 
 	test("returns enabled and config for existing source", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			enabled: true,
 			config: { units: "metric" },
 		})
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await get(app, "aelis.weather")
+		const res = await get(app, "freya.weather")
 
 		expect(res.status).toBe(200)
 		const body = (await res.json()) as { enabled: boolean; config: unknown }
@@ -224,9 +241,9 @@ describe("GET /api/sources/:sourceId", () => {
 
 	test("returns defaults when user has no row for source", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await get(app, "aelis.weather")
+		const res = await get(app, "freya.weather")
 
 		expect(res.status).toBe(200)
 		const body = (await res.json()) as { enabled: boolean; config: unknown }
@@ -236,13 +253,13 @@ describe("GET /api/sources/:sourceId", () => {
 
 	test("returns disabled source", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			enabled: false,
 			config: { units: "imperial" },
 		})
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await get(app, "aelis.weather")
+		const res = await get(app, "freya.weather")
 
 		expect(res.status).toBe(200)
 		const body = (await res.json()) as { enabled: boolean; config: unknown }
@@ -254,16 +271,16 @@ describe("GET /api/sources/:sourceId", () => {
 describe("PATCH /api/sources/:sourceId", () => {
 	test("returns 401 without auth", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)])
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)])
 
-		const res = await patch(app, "aelis.weather", { enabled: true })
+		const res = await patch(app, "freya.weather", { enabled: true })
 
 		expect(res.status).toBe(401)
 	})
 
 	test("returns 404 for unknown source", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
 		const res = await patch(app, "unknown.source", { enabled: true })
 
@@ -274,9 +291,9 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("returns 404 when user has no existing row for source", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", { enabled: true })
+		const res = await patch(app, "freya.weather", { enabled: true })
 
 		expect(res.status).toBe(404)
 		const body = (await res.json()) as { error: string }
@@ -285,29 +302,29 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("returns 204 when body is empty object (no-op) on existing source", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather")
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.weather")
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", {})
+		const res = await patch(app, "freya.weather", {})
 
 		expect(res.status).toBe(204)
 	})
 
 	test("returns 404 when body is empty object on nonexistent user source", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", {})
+		const res = await patch(app, "freya.weather", {})
 
 		expect(res.status).toBe(404)
 	})
 
 	test("returns 400 for invalid JSON body", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather")
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.weather")
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await app.request("/api/sources/aelis.weather", {
+		const res = await app.request("/api/sources/freya.weather", {
 			method: "PATCH",
 			headers: { "Content-Type": "application/json" },
 			body: "not json",
@@ -320,10 +337,10 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("returns 400 when request body contains unknown fields", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather")
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.weather")
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", {
+		const res = await patch(app, "freya.weather", {
 			enabled: true,
 			unknownField: "hello",
 		})
@@ -333,10 +350,10 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("returns 400 when weather config contains unknown fields", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather")
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.weather")
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", {
+		const res = await patch(app, "freya.weather", {
 			config: { units: "metric", unknownField: "hello" },
 		})
 
@@ -345,10 +362,10 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("returns 400 when weather config fails validation", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather")
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.weather")
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", {
+		const res = await patch(app, "freya.weather", {
 			config: { units: "invalid" },
 		})
 
@@ -357,65 +374,65 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("returns 204 and updates enabled", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			enabled: true,
 			config: { units: "metric" },
 		})
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", { enabled: false })
+		const res = await patch(app, "freya.weather", { enabled: false })
 
 		expect(res.status).toBe(204)
-		const row = activeStore.rows.get(`${MOCK_USER_ID}:aelis.weather`)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.weather`)
 		expect(row!.enabled).toBe(false)
 		expect(row!.config).toEqual({ units: "metric" })
 	})
 
 	test("returns 204 and updates config", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			config: { units: "metric" },
 		})
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", {
+		const res = await patch(app, "freya.weather", {
 			config: { units: "imperial" },
 		})
 
 		expect(res.status).toBe(204)
-		const row = activeStore.rows.get(`${MOCK_USER_ID}:aelis.weather`)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.weather`)
 		expect(row!.config).toEqual({ units: "imperial" })
 	})
 
 	test("preserves config when only updating enabled", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.tfl", {
+		activeStore.seed(MOCK_USER_ID, "freya.tfl", {
 			enabled: true,
 			config: { lines: ["bakerloo"] },
 		})
-		const { app } = createApp([createStubProvider("aelis.tfl", tflConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.tfl", tflConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.tfl", { enabled: false })
+		const res = await patch(app, "freya.tfl", { enabled: false })
 
 		expect(res.status).toBe(204)
-		const row = activeStore.rows.get(`${MOCK_USER_ID}:aelis.tfl`)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.tfl`)
 		expect(row!.enabled).toBe(false)
 		expect(row!.config).toEqual({ lines: ["bakerloo"] })
 	})
 
 	test("deep-merges config on update", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			config: { units: "metric", hourlyLimit: 12 },
 		})
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.weather", {
+		const res = await patch(app, "freya.weather", {
 			config: { dailyLimit: 5 },
 		})
 
 		expect(res.status).toBe(204)
-		const row = activeStore.rows.get(`${MOCK_USER_ID}:aelis.weather`)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.weather`)
 		expect(row!.config).toEqual({
 			units: "metric",
 			hourlyLimit: 12,
@@ -425,18 +442,18 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("refreshes source in active session after config update", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			config: { units: "metric" },
 		})
 		const { app, sessionManager } = createApp(
-			[createStubProvider("aelis.weather", weatherConfig)],
+			[createStubProvider("freya.weather", weatherConfig)],
 			MOCK_USER_ID,
 		)
 
 		const session = await sessionManager.getOrCreate(MOCK_USER_ID)
 		const replaceSpy = spyOn(session, "replaceSource")
 
-		const res = await patch(app, "aelis.weather", {
+		const res = await patch(app, "freya.weather", {
 			config: { units: "imperial" },
 		})
 
@@ -447,31 +464,31 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("removes source from session when disabled", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			enabled: true,
 			config: { units: "metric" },
 		})
 		const { app, sessionManager } = createApp(
-			[createStubProvider("aelis.weather", weatherConfig)],
+			[createStubProvider("freya.weather", weatherConfig)],
 			MOCK_USER_ID,
 		)
 
 		const session = await sessionManager.getOrCreate(MOCK_USER_ID)
 		const removeSpy = spyOn(session, "removeSource")
 
-		const res = await patch(app, "aelis.weather", { enabled: false })
+		const res = await patch(app, "freya.weather", { enabled: false })
 
 		expect(res.status).toBe(204)
-		expect(removeSpy).toHaveBeenCalledWith("aelis.weather")
+		expect(removeSpy).toHaveBeenCalledWith("freya.weather")
 		removeSpy.mockRestore()
 	})
 
 	test("returns 400 when config is provided for source without schema", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.location")
-		const { app } = createApp([createStubProvider("aelis.location")], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.location")
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.location", {
+		const res = await patch(app, "freya.location", {
 			config: { something: "value" },
 		})
 
@@ -480,10 +497,10 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("returns 400 when empty config is provided for source without schema", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.location")
-		const { app } = createApp([createStubProvider("aelis.location")], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.location")
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.location", {
+		const res = await patch(app, "freya.location", {
 			config: {},
 		})
 
@@ -492,13 +509,13 @@ describe("PATCH /api/sources/:sourceId", () => {
 
 	test("updates enabled on location source", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.location", { enabled: true })
-		const { app } = createApp([createStubProvider("aelis.location")], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.location", { enabled: true })
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await patch(app, "aelis.location", { enabled: false })
+		const res = await patch(app, "freya.location", { enabled: false })
 
 		expect(res.status).toBe(204)
-		const row = activeStore.rows.get(`${MOCK_USER_ID}:aelis.location`)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.location`)
 		expect(row!.enabled).toBe(false)
 	})
 })
@@ -510,16 +527,16 @@ describe("PATCH /api/sources/:sourceId", () => {
 describe("PUT /api/sources/:sourceId", () => {
 	test("returns 401 without auth", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)])
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)])
 
-		const res = await put(app, "aelis.weather", { enabled: true, config: {} })
+		const res = await put(app, "freya.weather", { enabled: true, config: {} })
 
 		expect(res.status).toBe(401)
 	})
 
 	test("returns 404 for unknown source", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
 		const res = await put(app, "unknown.source", { enabled: true, config: {} })
 
@@ -530,9 +547,9 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 400 for invalid JSON", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await app.request("/api/sources/aelis.weather", {
+		const res = await app.request("/api/sources/freya.weather", {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: "not json",
@@ -545,27 +562,27 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 400 when enabled is missing", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.weather", { config: {} })
+		const res = await put(app, "freya.weather", { config: {} })
 
 		expect(res.status).toBe(400)
 	})
 
 	test("returns 400 when config is missing", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.weather", { enabled: true })
+		const res = await put(app, "freya.weather", { enabled: true })
 
 		expect(res.status).toBe(400)
 	})
 
 	test("returns 400 when request body contains unknown fields", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: true,
 			config: { units: "metric" },
 			unknownField: "hello",
@@ -576,9 +593,9 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 400 when weather config contains unknown fields", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: true,
 			config: { units: "metric", unknownField: "hello" },
 		})
@@ -588,9 +605,9 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 400 when config fails schema validation", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: true,
 			config: { units: "invalid" },
 		})
@@ -600,15 +617,15 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 204 and inserts when row does not exist", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: true,
 			config: { units: "metric" },
 		})
 
 		expect(res.status).toBe(204)
-		const row = activeStore.rows.get(`${MOCK_USER_ID}:aelis.weather`)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.weather`)
 		expect(row).toBeDefined()
 		expect(row!.enabled).toBe(true)
 		expect(row!.config).toEqual({ units: "metric" })
@@ -616,19 +633,19 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 204 and fully replaces existing row", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			enabled: true,
 			config: { units: "metric", hourlyLimit: 12 },
 		})
-		const { app } = createApp([createStubProvider("aelis.weather", weatherConfig)], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: false,
 			config: { units: "imperial" },
 		})
 
 		expect(res.status).toBe(204)
-		const row = activeStore.rows.get(`${MOCK_USER_ID}:aelis.weather`)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.weather`)
 		expect(row!.enabled).toBe(false)
 		// hourlyLimit should be gone — full replace, not merge
 		expect(row!.config).toEqual({ units: "imperial" })
@@ -636,18 +653,18 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("refreshes source in active session after upsert", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			config: { units: "metric" },
 		})
 		const { app, sessionManager } = createApp(
-			[createStubProvider("aelis.weather", weatherConfig)],
+			[createStubProvider("freya.weather", weatherConfig)],
 			MOCK_USER_ID,
 		)
 
 		const session = await sessionManager.getOrCreate(MOCK_USER_ID)
 		const replaceSpy = spyOn(session, "replaceSource")
 
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: true,
 			config: { units: "imperial" },
 		})
@@ -659,56 +676,56 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("removes source from session when disabled via upsert", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.weather", {
+		activeStore.seed(MOCK_USER_ID, "freya.weather", {
 			enabled: true,
 			config: { units: "metric" },
 		})
 		const { app, sessionManager } = createApp(
-			[createStubProvider("aelis.weather", weatherConfig)],
+			[createStubProvider("freya.weather", weatherConfig)],
 			MOCK_USER_ID,
 		)
 
 		const session = await sessionManager.getOrCreate(MOCK_USER_ID)
 		const removeSpy = spyOn(session, "removeSource")
 
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: false,
 			config: { units: "metric" },
 		})
 
 		expect(res.status).toBe(204)
-		expect(removeSpy).toHaveBeenCalledWith("aelis.weather")
+		expect(removeSpy).toHaveBeenCalledWith("freya.weather")
 		removeSpy.mockRestore()
 	})
 
 	test("adds source to active session when inserting a new source", async () => {
 		activeStore = createInMemoryStore()
 		// Seed a different source so the session can be created
-		activeStore.seed(MOCK_USER_ID, "aelis.location", { enabled: true })
+		activeStore.seed(MOCK_USER_ID, "freya.location", { enabled: true })
 		const { app, sessionManager } = createApp(
-			[createStubProvider("aelis.location"), createStubProvider("aelis.weather", weatherConfig)],
+			[createStubProvider("freya.location"), createStubProvider("freya.weather", weatherConfig)],
 			MOCK_USER_ID,
 		)
 
-		// Create session — only has aelis.location
+		// Create session — only has freya.location
 		const session = await sessionManager.getOrCreate(MOCK_USER_ID)
-		expect(session.hasSource("aelis.weather")).toBe(false)
+		expect(session.hasSource("freya.weather")).toBe(false)
 
 		// PUT a new source that didn't exist before
-		const res = await put(app, "aelis.weather", {
+		const res = await put(app, "freya.weather", {
 			enabled: true,
 			config: { units: "metric" },
 		})
 
 		expect(res.status).toBe(204)
-		expect(session.hasSource("aelis.weather")).toBe(true)
+		expect(session.hasSource("freya.weather")).toBe(true)
 	})
 
 	test("returns 400 when config is provided for source without schema", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.location")], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.location", {
+		const res = await put(app, "freya.location", {
 			enabled: true,
 			config: { something: "value" },
 		})
@@ -718,9 +735,9 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 400 when empty config is provided for source without schema", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.location")], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.location", {
+		const res = await put(app, "freya.location", {
 			enabled: true,
 			config: {},
 		})
@@ -730,29 +747,227 @@ describe("PUT /api/sources/:sourceId", () => {
 
 	test("returns 204 without config field for source without schema", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createApp([createStubProvider("aelis.location")], MOCK_USER_ID)
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await put(app, "aelis.location", {
+		const res = await put(app, "freya.location", {
 			enabled: true,
 		})
 
 		expect(res.status).toBe(204)
 	})
+
+	test("returns 204 when credentials are included alongside config", async () => {
+		activeStore = createInMemoryStore()
+		const { app } = createAppWithEncryptor(
+			[createStubProvider("freya.weather", weatherConfig)],
+			MOCK_USER_ID,
+		)
+
+		const res = await put(app, "freya.weather", {
+			enabled: true,
+			config: { units: "metric" },
+			credentials: { apiKey: "secret123" },
+		})
+
+		expect(res.status).toBe(204)
+		const row = activeStore.rows.get(`${MOCK_USER_ID}:freya.weather`)
+		expect(row).toBeDefined()
+		expect(row!.enabled).toBe(true)
+		expect(row!.config).toEqual({ units: "metric" })
+	})
+
+	test("returns 503 when credentials are provided but no encryptor is configured", async () => {
+		activeStore = createInMemoryStore()
+		// createApp does NOT configure an encryptor
+		const { app } = createApp([createStubProvider("freya.weather", weatherConfig)], MOCK_USER_ID)
+
+		const res = await put(app, "freya.weather", {
+			enabled: true,
+			config: { units: "metric" },
+			credentials: { apiKey: "secret123" },
+		})
+
+		expect(res.status).toBe(503)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toContain("not configured")
+	})
+})
+
+describe("GET /api/sources/:sourceId/actions", () => {
+	test("returns 401 without auth", async () => {
+		activeStore = createInMemoryStore()
+		const { app } = createApp([createStubProvider("freya.location")])
+
+		const res = await listActions(app, "freya.location")
+
+		expect(res.status).toBe(401)
+	})
+
+	test("returns 404 for source that is not enabled in the user session", async () => {
+		activeStore = createInMemoryStore()
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
+
+		const res = await listActions(app, "freya.location")
+
+		expect(res.status).toBe(404)
+	})
+
+	test("returns serializable action definitions", async () => {
+		activeStore = createInMemoryStore()
+		activeStore.seed(MOCK_USER_ID, "test.actions")
+		const provider: FeedSourceProvider = {
+			sourceId: "test.actions",
+			async feedSourceForUser() {
+				return {
+					id: "test.actions",
+					async listActions() {
+						return {
+							search: {
+								id: "search",
+								description: "Search something",
+								input: tflConfig,
+							},
+						}
+					},
+					async executeAction() {
+						return undefined
+					},
+					async fetchContext() {
+						return null
+					},
+				}
+			},
+		}
+		const { app } = createApp([provider], MOCK_USER_ID)
+
+		const res = await listActions(app, "test.actions")
+
+		expect(res.status).toBe(200)
+		const body = (await res.json()) as {
+			actions: Record<string, { id: string; description?: string; input?: unknown }>
+		}
+		expect(body.actions.search).toEqual({
+			id: "search",
+			description: "Search something",
+		})
+	})
+})
+
+describe("POST /api/sources/:sourceId/actions/:actionId", () => {
+	test("returns 401 without auth", async () => {
+		activeStore = createInMemoryStore()
+		const { app } = createApp([createStubProvider("freya.location")])
+
+		const res = await executeAction(app, "freya.location", "update-location", {})
+
+		expect(res.status).toBe(401)
+	})
+
+	test("executes source action with request body as params", async () => {
+		activeStore = createInMemoryStore()
+		activeStore.seed(MOCK_USER_ID, "test.actions")
+		let receivedParams: unknown
+		const provider: FeedSourceProvider = {
+			sourceId: "test.actions",
+			async feedSourceForUser() {
+				return {
+					id: "test.actions",
+					async listActions() {
+						return {
+							search: { id: "search", description: "Search something" },
+						}
+					},
+					async executeAction(_actionId: string, params: unknown) {
+						receivedParams = params
+						return { ok: true, count: 2 }
+					},
+					async fetchContext() {
+						return null
+					},
+				}
+			},
+		}
+		const { app } = createApp([provider], MOCK_USER_ID)
+
+		const res = await executeAction(app, "test.actions", "search", { query: "exa" })
+
+		expect(res.status).toBe(200)
+		expect(receivedParams).toEqual({ query: "exa" })
+		const body = (await res.json()) as { result: unknown }
+		expect(body.result).toEqual({ ok: true, count: 2 })
+	})
+
+	test("returns 404 for unknown action", async () => {
+		activeStore = createInMemoryStore()
+		activeStore.seed(MOCK_USER_ID, "freya.location")
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
+
+		const res = await executeAction(app, "freya.location", "missing", {})
+
+		expect(res.status).toBe(404)
+	})
+
+	test("returns 400 for invalid JSON", async () => {
+		activeStore = createInMemoryStore()
+		activeStore.seed(MOCK_USER_ID, "freya.location")
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
+
+		const res = await app.request("/api/sources/freya.location/actions/search", {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: "not-json",
+		})
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toBe("Invalid JSON")
+	})
+
+	test("returns 400 when source rejects params", async () => {
+		activeStore = createInMemoryStore()
+		activeStore.seed(MOCK_USER_ID, "test.actions")
+		const provider: FeedSourceProvider = {
+			sourceId: "test.actions",
+			async feedSourceForUser() {
+				return {
+					id: "test.actions",
+					async listActions() {
+						return {
+							search: { id: "search" },
+						}
+					},
+					async executeAction() {
+						throw new Error("query must not be empty")
+					},
+					async fetchContext() {
+						return null
+					},
+				}
+			},
+		}
+		const { app } = createApp([provider], MOCK_USER_ID)
+
+		const res = await executeAction(app, "test.actions", "search", { query: "" })
+
+		expect(res.status).toBe(400)
+		const body = (await res.json()) as { error: string }
+		expect(body.error).toBe("query must not be empty")
+	})
 })
 
 describe("PUT /api/sources/:sourceId/credentials", () => {
 	test("returns 401 without auth", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createAppWithEncryptor([createStubProvider("aelis.location")])
+		const { app } = createAppWithEncryptor([createStubProvider("freya.location")])
 
-		const res = await putCredentials(app, "aelis.location", { token: "x" })
+		const res = await putCredentials(app, "freya.location", { token: "x" })
 
 		expect(res.status).toBe(401)
 	})
 
 	test("returns 404 for unknown source", async () => {
 		activeStore = createInMemoryStore()
-		const { app } = createAppWithEncryptor([createStubProvider("aelis.location")], MOCK_USER_ID)
+		const { app } = createAppWithEncryptor([createStubProvider("freya.location")], MOCK_USER_ID)
 
 		const res = await putCredentials(app, "unknown.source", { token: "x" })
 
@@ -761,10 +976,10 @@ describe("PUT /api/sources/:sourceId/credentials", () => {
 
 	test("returns 400 for invalid JSON", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.location")
-		const { app } = createAppWithEncryptor([createStubProvider("aelis.location")], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.location")
+		const { app } = createAppWithEncryptor([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await app.request("/api/sources/aelis.location/credentials", {
+		const res = await app.request("/api/sources/freya.location/credentials", {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: "not-json",
@@ -777,10 +992,10 @@ describe("PUT /api/sources/:sourceId/credentials", () => {
 
 	test("returns 204 and persists credentials", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.location")
-		const { app } = createAppWithEncryptor([createStubProvider("aelis.location")], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.location")
+		const { app } = createAppWithEncryptor([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await putCredentials(app, "aelis.location", { token: "secret" })
+		const res = await putCredentials(app, "freya.location", { token: "secret" })
 
 		expect(res.status).toBe(204)
 	})
@@ -812,10 +1027,10 @@ describe("PUT /api/sources/:sourceId/credentials", () => {
 
 	test("returns 503 when credential encryption is not configured", async () => {
 		activeStore = createInMemoryStore()
-		activeStore.seed(MOCK_USER_ID, "aelis.location")
-		const { app } = createApp([createStubProvider("aelis.location")], MOCK_USER_ID)
+		activeStore.seed(MOCK_USER_ID, "freya.location")
+		const { app } = createApp([createStubProvider("freya.location")], MOCK_USER_ID)
 
-		const res = await putCredentials(app, "aelis.location", { token: "x" })
+		const res = await putCredentials(app, "freya.location", { token: "x" })
 
 		expect(res.status).toBe(503)
 		const body = (await res.json()) as { error: string }

apps/freya-backend/src/sources/http.ts

@@ -1,3 +1,4 @@
+import type { ActionDefinition } from "@freya/core"
 import type { Context, Hono } from "hono"
 
 import { type } from "arktype"
@@ -34,11 +35,13 @@ const ReplaceSourceConfigRequestBody = type({
 	"+": "reject",
 	enabled: "boolean",
 	config: "unknown",
+	"credentials?": "unknown",
 })
 
 const ReplaceSourceConfigNoConfigRequestBody = type({
 	"+": "reject",
 	enabled: "boolean",
+	"credentials?": "unknown",
 })
 
 export function registerSourcesHttpHandlers(
@@ -53,6 +56,13 @@ export function registerSourcesHttpHandlers(
 	app.get("/api/sources/:sourceId", inject, authSessionMiddleware, handleGetSource)
 	app.patch("/api/sources/:sourceId", inject, authSessionMiddleware, handleUpdateSource)
 	app.put("/api/sources/:sourceId", inject, authSessionMiddleware, handleReplaceSource)
+	app.get("/api/sources/:sourceId/actions", inject, authSessionMiddleware, handleListActions)
+	app.post(
+		"/api/sources/:sourceId/actions/:actionId",
+		inject,
+		authSessionMiddleware,
+		handleExecuteAction,
+	)
 	app.put(
 		"/api/sources/:sourceId/credentials",
 		inject,
@@ -161,14 +171,15 @@ async function handleReplaceSource(c: Context<Env>) {
 		return c.json({ error: parsed.summary }, 400)
 	}
 
-	const { enabled } = parsed
+	const { enabled, credentials } = parsed
 	const config = "config" in parsed ? parsed.config : undefined
 	const user = c.get("user")!
 
 	try {
-		await sessionManager.upsertSourceConfig(user.id, sourceId, {
+		await sessionManager.saveSourceConfig(user.id, sourceId, {
 			enabled,
 			config,
+			credentials,
 		})
 	} catch (err) {
 		if (err instanceof SourceNotFoundError) {
@@ -177,12 +188,80 @@ async function handleReplaceSource(c: Context<Env>) {
 		if (err instanceof InvalidSourceConfigError) {
 			return c.json({ error: err.message }, 400)
 		}
+		if (err instanceof CredentialStorageUnavailableError) {
+			return c.json({ error: err.message }, 503)
+		}
 		throw err
 	}
 
 	return c.body(null, 204)
 }
 
+async function handleListActions(c: Context<Env>) {
+	const sourceId = c.req.param("sourceId")
+	if (!sourceId) {
+		return c.body(null, 404)
+	}
+
+	const user = c.get("user")!
+	const sessionManager = c.get("sessionManager")
+
+	let session
+	try {
+		session = await sessionManager.getOrCreate(user.id)
+	} catch (err) {
+		console.error("[handleListActions] Failed to create session:", err)
+		return c.json({ error: "Service unavailable" }, 503)
+	}
+
+	try {
+		const actions = await session.engine.listActions(sourceId)
+		return c.json({ actions: serializeActions(actions) })
+	} catch (err) {
+		if (isActionNotFoundError(err)) {
+			return c.json({ error: err.message }, 404)
+		}
+		console.error(`[handleListActions] Failed to list actions for "${sourceId}":`, err)
+		return c.json({ error: "Failed to list actions" }, 500)
+	}
+}
+
+async function handleExecuteAction(c: Context<Env>) {
+	const sourceId = c.req.param("sourceId")
+	const actionId = c.req.param("actionId")
+	if (!sourceId || !actionId) {
+		return c.body(null, 404)
+	}
+
+	let params: unknown
+	try {
+		params = await c.req.json()
+	} catch {
+		return c.json({ error: "Invalid JSON" }, 400)
+	}
+
+	const user = c.get("user")!
+	const sessionManager = c.get("sessionManager")
+
+	let session
+	try {
+		session = await sessionManager.getOrCreate(user.id)
+	} catch (err) {
+		console.error("[handleExecuteAction] Failed to create session:", err)
+		return c.json({ error: "Service unavailable" }, 503)
+	}
+
+	try {
+		const result = await session.engine.executeAction(sourceId, actionId, params)
+		return c.json({ result })
+	} catch (err) {
+		if (isActionNotFoundError(err)) {
+			return c.json({ error: err.message }, 404)
+		}
+		return c.json({ error: err instanceof Error ? err.message : String(err) }, 400)
+	}
+}
+
 async function handleUpdateCredentials(c: Context<Env>) {
 	const sourceId = c.req.param("sourceId")
 	if (!sourceId) {
@@ -222,3 +301,21 @@ async function handleUpdateCredentials(c: Context<Env>) {
 
 	return c.body(null, 204)
 }
+
+function serializeActions(actions: Record<string, ActionDefinition>) {
+	const serialized: Record<string, { id: string; description?: string }> = {}
+	for (const [key, action] of Object.entries(actions)) {
+		serialized[key] = {
+			id: action.id,
+			...(action.description ? { description: action.description } : {}),
+		}
+	}
+	return serialized
+}
+
+function isActionNotFoundError(err: unknown): err is Error {
+	if (!(err instanceof Error)) {
+		return false
+	}
+	return err.message.startsWith("Source not found:") || err.message.startsWith("Action ")
+}

apps/freya-backend/src/sources/user-sources.ts

@@ -26,6 +26,18 @@ export function sources(db: Database, userId: string) {
 			return rows[0]
 		},
 
+		/** Like find(), but acquires a row lock to prevent concurrent modifications. Must be called inside a transaction. */
+		async findForUpdate(sourceId: string) {
+			const rows = await db
+				.select()
+				.from(userSources)
+				.where(and(eq(userSources.userId, userId), eq(userSources.sourceId, sourceId)))
+				.limit(1)
+				.for("update")
+
+			return rows[0]
+		},
+
 		/** Enables a source for the user. Throws if the source row doesn't exist. */
 		async enableSource(sourceId: string) {
 			const rows = await db

apps/freya-backend/src/tfl/provider.ts

@@ -1,4 +1,4 @@
-import { TflSource, type ITflApi, type TflLineId } from "@aelis/source-tfl"
+import { TflSource, type ITflApi, type TflLineId } from "@freya/source-tfl"
 import { type } from "arktype"
 
 import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
@@ -13,7 +13,7 @@ export const tflConfig = type({
 })
 
 export class TflSourceProvider implements FeedSourceProvider {
-	readonly sourceId = "aelis.tfl"
+	readonly sourceId = "freya.tfl"
 	readonly configSchema = tflConfig
 	private readonly apiKey: string | undefined
 	private readonly client: ITflApi | undefined

apps/freya-backend/src/weather/provider.ts

@@ -1,4 +1,4 @@
-import { WeatherSource, type WeatherSourceOptions } from "@aelis/source-weatherkit"
+import { WeatherSource, type WeatherSourceOptions } from "@freya/source-weatherkit"
 import { type } from "arktype"
 
 import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
@@ -16,7 +16,7 @@ export const weatherConfig = type({
 })
 
 export class WeatherSourceProvider implements FeedSourceProvider {
-	readonly sourceId = "aelis.weather"
+	readonly sourceId = "freya.weather"
 	readonly configSchema = weatherConfig
 	private readonly credentials: WeatherSourceOptions["credentials"]
 	private readonly client: WeatherSourceOptions["client"]

apps/freya-backend/src/web-search/provider.ts

@@ -0,0 +1,30 @@
+import { WebSearchSource, type WebSearchClient } from "@freya/source-web-search"
+
+import type { FeedSourceProvider } from "../session/feed-source-provider.ts"
+
+export type WebSearchSourceProviderOptions =
+	| { apiKey: string | undefined; client?: never }
+	| { apiKey?: never; client: WebSearchClient }
+
+export class WebSearchSourceProvider implements FeedSourceProvider {
+	readonly sourceId = "freya.web-search"
+
+	private readonly apiKey: string | undefined
+	private readonly client: WebSearchClient | undefined
+
+	constructor(options: WebSearchSourceProviderOptions) {
+		this.apiKey = "apiKey" in options ? options.apiKey : undefined
+		this.client = "client" in options ? options.client : undefined
+	}
+
+	async feedSourceForUser(
+		_userId: string,
+		_config: unknown,
+		_credentials: unknown,
+	): Promise<WebSearchSource> {
+		return new WebSearchSource({
+			apiKey: this.apiKey,
+			client: this.client,
+		})
+	}
+}

apps/freya-client/app.json

@@ -1,11 +1,11 @@
 {
 	"expo": {
-		"name": "Aelis",
-		"slug": "aelis-client",
+		"name": "Freya",
+		"slug": "freya-client",
 		"version": "1.0.0",
 		"orientation": "portrait",
 		"icon": "./assets/images/icon.png",
-		"scheme": "aelis",
+		"scheme": "freya",
 		"userInterfaceStyle": "automatic",
 		"newArchEnabled": true,
 		"ios": {
@@ -15,7 +15,7 @@
 				},
 				"ITSAppUsesNonExemptEncryption": false
 			},
-			"bundleIdentifier": "sh.nym.aelis"
+			"bundleIdentifier": "sh.nym.freya"
 		},
 		"android": {
 			"adaptiveIcon": {
@@ -26,7 +26,7 @@
 			},
 			"edgeToEdgeEnabled": true,
 			"predictiveBackGestureEnabled": false,
-			"package": "sh.nym.aelis"
+			"package": "sh.nym.freya"
 		},
 		"web": {
 			"output": "static",
@@ -55,44 +55,112 @@
 								"fontFamily": "Inter",
 								"fontDefinitions": [
 									{ "path": "./assets/fonts/Inter_100Thin.ttf", "weight": 100 },
-									{ "path": "./assets/fonts/Inter_100Thin_Italic.ttf", "weight": 100, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_100Thin_Italic.ttf",
+										"weight": 100,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_200ExtraLight.ttf", "weight": 200 },
-									{ "path": "./assets/fonts/Inter_200ExtraLight_Italic.ttf", "weight": 200, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_200ExtraLight_Italic.ttf",
+										"weight": 200,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_300Light.ttf", "weight": 300 },
-									{ "path": "./assets/fonts/Inter_300Light_Italic.ttf", "weight": 300, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_300Light_Italic.ttf",
+										"weight": 300,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_400Regular.ttf", "weight": 400 },
-									{ "path": "./assets/fonts/Inter_400Regular_Italic.ttf", "weight": 400, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_400Regular_Italic.ttf",
+										"weight": 400,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_500Medium.ttf", "weight": 500 },
-									{ "path": "./assets/fonts/Inter_500Medium_Italic.ttf", "weight": 500, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_500Medium_Italic.ttf",
+										"weight": 500,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_600SemiBold.ttf", "weight": 600 },
-									{ "path": "./assets/fonts/Inter_600SemiBold_Italic.ttf", "weight": 600, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_600SemiBold_Italic.ttf",
+										"weight": 600,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_700Bold.ttf", "weight": 700 },
-									{ "path": "./assets/fonts/Inter_700Bold_Italic.ttf", "weight": 700, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_700Bold_Italic.ttf",
+										"weight": 700,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_800ExtraBold.ttf", "weight": 800 },
-									{ "path": "./assets/fonts/Inter_800ExtraBold_Italic.ttf", "weight": 800, "style": "italic" },
+									{
+										"path": "./assets/fonts/Inter_800ExtraBold_Italic.ttf",
+										"weight": 800,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/Inter_900Black.ttf", "weight": 900 },
-									{ "path": "./assets/fonts/Inter_900Black_Italic.ttf", "weight": 900, "style": "italic" }
+									{
+										"path": "./assets/fonts/Inter_900Black_Italic.ttf",
+										"weight": 900,
+										"style": "italic"
+									}
 								]
 							},
 							{
 								"fontFamily": "Source Serif 4",
 								"fontDefinitions": [
 									{ "path": "./assets/fonts/SourceSerif4_200ExtraLight.ttf", "weight": 200 },
-									{ "path": "./assets/fonts/SourceSerif4_200ExtraLight_Italic.ttf", "weight": 200, "style": "italic" },
+									{
+										"path": "./assets/fonts/SourceSerif4_200ExtraLight_Italic.ttf",
+										"weight": 200,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/SourceSerif4_300Light.ttf", "weight": 300 },
-									{ "path": "./assets/fonts/SourceSerif4_300Light_Italic.ttf", "weight": 300, "style": "italic" },
+									{
+										"path": "./assets/fonts/SourceSerif4_300Light_Italic.ttf",
+										"weight": 300,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/SourceSerif4_400Regular.ttf", "weight": 400 },
-									{ "path": "./assets/fonts/SourceSerif4_400Regular_Italic.ttf", "weight": 400, "style": "italic" },
+									{
+										"path": "./assets/fonts/SourceSerif4_400Regular_Italic.ttf",
+										"weight": 400,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/SourceSerif4_500Medium.ttf", "weight": 500 },
-									{ "path": "./assets/fonts/SourceSerif4_500Medium_Italic.ttf", "weight": 500, "style": "italic" },
+									{
+										"path": "./assets/fonts/SourceSerif4_500Medium_Italic.ttf",
+										"weight": 500,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/SourceSerif4_600SemiBold.ttf", "weight": 600 },
-									{ "path": "./assets/fonts/SourceSerif4_600SemiBold_Italic.ttf", "weight": 600, "style": "italic" },
+									{
+										"path": "./assets/fonts/SourceSerif4_600SemiBold_Italic.ttf",
+										"weight": 600,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/SourceSerif4_700Bold.ttf", "weight": 700 },
-									{ "path": "./assets/fonts/SourceSerif4_700Bold_Italic.ttf", "weight": 700, "style": "italic" },
+									{
+										"path": "./assets/fonts/SourceSerif4_700Bold_Italic.ttf",
+										"weight": 700,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/SourceSerif4_800ExtraBold.ttf", "weight": 800 },
-									{ "path": "./assets/fonts/SourceSerif4_800ExtraBold_Italic.ttf", "weight": 800, "style": "italic" },
+									{
+										"path": "./assets/fonts/SourceSerif4_800ExtraBold_Italic.ttf",
+										"weight": 800,
+										"style": "italic"
+									},
 									{ "path": "./assets/fonts/SourceSerif4_900Black.ttf", "weight": 900 },
-									{ "path": "./assets/fonts/SourceSerif4_900Black_Italic.ttf", "weight": 900, "style": "italic" }
+									{
+										"path": "./assets/fonts/SourceSerif4_900Black_Italic.ttf",
+										"weight": 900,
+										"style": "italic"
+									}
 								]
 							}
 						]