diff --git a/.agents/skills/migrate-to-sqlite/SKILL.md b/.agents/skills/migrate-to-sqlite/SKILL.md
index f138f9d0e1..5eb63d3215 100644
--- a/.agents/skills/migrate-to-sqlite/SKILL.md
+++ b/.agents/skills/migrate-to-sqlite/SKILL.md
@@ -7,11 +7,22 @@ description: Migrate a TinyBase table to SQLite. Use when asked to move a data d
 
 - **Schema source of truth:** Rust migration in `crates/db-app/migrations/`
 - **Drizzle mirror:** `packages/db/src/schema.ts` (typed TS query interface, not schema management)
-- **Reads (reactive):** `useDrizzleLiveQuery` — calls `.toSQL()` on a Drizzle query, feeds `{sql, params}` to `useLiveQuery` which uses `subscribe()` from `@hypr/plugin-db`
+- **Reads (reactive):** `useDrizzleLiveQuery` — calls `.toSQL()` on a Drizzle query, feeds `{sql, params}` to the underlying `useLiveQuery` which uses `subscribe()` from `@hypr/plugin-db`
 - **Reads (imperative):** `db.select()...` through the Drizzle sqlite-proxy driver
 - **Writes:** `db.insert()`, `db.update()`, `db.delete()` through the Drizzle sqlite-proxy driver, wrapped in `useMutation` from tanstack-query
 - **Reactivity loop:** write via `execute` → SQLite change → Rust `db-live-query` notifies subscribers → `useLiveQuery` fires `onData` → React re-renders. No manual invalidation needed.
 
+### Package layers
+
+The DB stack uses a factory/DI pattern across four packages:
+
+1. `@hypr/db-runtime` (`packages/db-runtime/`) — type contracts only: `LiveQueryClient`, `DrizzleProxyClient`, shared row/query types.
+2. `@hypr/db` (`packages/db/`) — Drizzle schema (`schema.ts`) + `createDb(client)` factory using `drizzle-orm/sqlite-proxy`. Re-exports Drizzle operators (`eq`, `and`, `sql`, etc.).
+3. `@hypr/db-tauri` (`packages/db-tauri/`) — Tauri-specific client that binds `execute`/`executeProxy`/`subscribe` from `@hypr/plugin-db` to the `db-runtime` types.
+4. `@hypr/db-react` (`packages/db-react/`) — `createUseLiveQuery(client)` and `createUseDrizzleLiveQuery(client)` factories.
+
+These are wired together in `apps/desktop/src/db/index.ts`, which exports `db`, `useLiveQuery`, and `useDrizzleLiveQuery`. **Consumer code imports from `~/db`, not directly from the packages.**
+
 ## Steps
 
 ### 1. Rust migration
@@ -39,7 +50,11 @@ Replace raw TinyBase reads/writes with:
 - `db.select()...` for imperative reads (returns parsed objects via proxy driver)
 - `db.insert()`, `db.update()`, `db.delete()` for writes, wrapped in `useMutation`
 
-Live query results come from Rust `subscribe` as raw objects (not through Drizzle driver), so `mapRows` must still handle JSON parsing for JSON columns.
+Import `db` and `useDrizzleLiveQuery` from `~/db` (the app-level wiring module), and schema tables/operators from `@hypr/db`.
+
+Live query results come from Rust `subscribe` as raw objects (not through the Drizzle driver), so `mapRows` must handle two things:
+- **JSON parsing** for JSON text columns (e.g. `sections_json`, `targets_json`).
+- **snake_case → camelCase mapping.** Live rows use the raw SQLite column names (`pin_order`, `targets_json`), while Drizzle's `$inferSelect` uses camelCase (`pinOrder`, `targetsJson`). Define a separate `<Domain>LiveRow` type with snake_case keys for `mapRows`, distinct from the Drizzle inferred type. See `TemplateLiveRow` in `apps/desktop/src/templates/queries.ts` for the pattern.
 
 ### 6. Remove TinyBase artifacts
 
diff --git a/apps/desktop/src/calendar/components/apple/calendar-selection.tsx b/apps/desktop/src/calendar/components/apple/calendar-selection.tsx
index b5e48181af..78da9247ca 100644
--- a/apps/desktop/src/calendar/components/apple/calendar-selection.tsx
+++ b/apps/desktop/src/calendar/components/apple/calendar-selection.tsx
@@ -7,8 +7,8 @@ import {
   type CalendarItem,
   CalendarSelection,
 } from "~/calendar/components/calendar-selection";
+import { useCalendars, useToggleCalendarEnabled } from "~/calendar/queries";
 import { useMountEffect } from "~/shared/hooks/useMountEffect";
-import * as main from "~/store/tinybase/store/main";
 
 const SUBSCRIBED_SOURCE_NAME = "Subscribed Calendars";
 
@@ -43,20 +43,20 @@ export function useAppleCalendarSelection() {
   const { cancelDebouncedSync, status, scheduleDebouncedSync, scheduleSync } =
     useSync();
 
-  const store = main.UI.useStore(main.STORE_ID);
-  const calendars = main.UI.useTable("calendars", main.STORE_ID);
+  const allCalendars = useCalendars();
+  const toggleEnabled = useToggleCalendarEnabled();
 
   const groups = useMemo((): CalendarGroup[] => {
-    const appleCalendars = Object.entries(calendars).filter(
-      ([_, cal]) => cal.provider === "apple",
+    const appleCalendars = allCalendars.filter(
+      (cal) => cal.provider === "apple",
     );
 
     const grouped = new Map<string, CalendarItem[]>();
-    for (const [id, cal] of appleCalendars) {
+    for (const cal of appleCalendars) {
       const source = cal.source || "Apple Calendar";
       if (!grouped.has(source)) grouped.set(source, []);
       grouped.get(source)!.push({
-        id,
+        id: cal.id,
         title: cal.name || "Untitled",
         color: cal.color ?? "#888",
         enabled: cal.enabled ?? false,
@@ -73,14 +73,14 @@ export function useAppleCalendarSelection() {
         if (b.sourceName === SUBSCRIBED_SOURCE_NAME) return -1;
         return 0;
       });
-  }, [calendars]);
+  }, [allCalendars]);
 
   const handleToggle = useCallback(
     (calendar: CalendarItem, enabled: boolean) => {
-      store?.setPartialRow("calendars", calendar.id, { enabled });
+      void toggleEnabled(calendar.id, enabled);
       scheduleDebouncedSync();
     },
-    [store, scheduleDebouncedSync],
+    [toggleEnabled, scheduleDebouncedSync],
   );
 
   const handleRefresh = useCallback(() => {
diff --git a/apps/desktop/src/calendar/components/event-chip.tsx b/apps/desktop/src/calendar/components/event-chip.tsx
index 18e84e0453..7adfadbff0 100644
--- a/apps/desktop/src/calendar/components/event-chip.tsx
+++ b/apps/desktop/src/calendar/components/event-chip.tsx
@@ -11,38 +11,32 @@ import {
 import { cn } from "@hypr/utils";
 
 import { toTz, useTimezone } from "~/calendar/hooks";
+import { useCalendarById, useEventById } from "~/calendar/queries";
 import { EventDisplay } from "~/session/components/outer-header/metadata";
-import { useEvent } from "~/store/tinybase/hooks";
 import * as main from "~/store/tinybase/store/main";
 import { getOrCreateSessionForEventId } from "~/store/tinybase/store/sessions";
 import { useTabs } from "~/store/zustand/tabs";
 
 function useCalendarColor(calendarId: string | null): string | null {
-  const calendar = main.UI.useRow("calendars", calendarId ?? "", main.STORE_ID);
+  const calendar = useCalendarById(calendarId);
   if (!calendarId) return null;
-  return calendar?.color ? String(calendar.color) : null;
+  return calendar?.color ?? null;
 }
 
 export function EventChip({ eventId }: { eventId: string }) {
   const tz = useTimezone();
-  const event = main.UI.useResultRow(
-    main.QUERIES.timelineEvents,
-    eventId,
-    main.STORE_ID,
-  );
-  const calendarColor = useCalendarColor(
-    (event?.calendar_id as string) ?? null,
-  );
+  const event = useEventById(eventId);
+  const calendarColor = useCalendarColor(event?.calendarId ?? null);
 
   if (!event || !event.title) {
     return null;
   }
 
-  const isAllDay = !!event.is_all_day;
+  const isAllDay = !!event.isAllDay;
   const color = calendarColor ?? "#888";
 
-  const startedAt = event.started_at
-    ? format(toTz(event.started_at as string, tz), "h:mm a")
+  const startedAt = event.startedAt
+    ? format(toTz(event.startedAt, tz), "h:mm a")
     : null;
 
   return (
@@ -56,7 +50,7 @@ export function EventChip({ eventId }: { eventId: string }) {
             ])}
             style={{ backgroundColor: color }}
           >
-            {event.title as string}
+            {event.title}
           </button>
         ) : (
           <button
@@ -69,7 +63,7 @@ export function EventChip({ eventId }: { eventId: string }) {
               className="w-[2.5px] shrink-0 self-stretch rounded-full"
               style={{ backgroundColor: color }}
             />
-            <span className="truncate">{event.title as string}</span>
+            <span className="truncate">{event.title}</span>
             {startedAt && (
               <span className="ml-auto shrink-0 font-mono text-neutral-400">
                 {startedAt}
@@ -93,22 +87,16 @@ export function EventChip({ eventId }: { eventId: string }) {
 }
 
 function EventPopoverContent({ eventId }: { eventId: string }) {
-  const event = useEvent(eventId);
+  const event = useEventById(eventId);
   const store = main.UI.useStore(main.STORE_ID);
   const openNew = useTabs((state) => state.openNew);
 
-  const eventRow = main.UI.useResultRow(
-    main.QUERIES.timelineEvents,
-    eventId,
-    main.STORE_ID,
-  );
-
-  const handleOpen = useCallback(() => {
+  const handleOpen = useCallback(async () => {
     if (!store) return;
-    const title = (eventRow?.title as string) || "Untitled";
-    const sessionId = getOrCreateSessionForEventId(store, eventId, title);
+    const title = event?.title || "Untitled";
+    const sessionId = await getOrCreateSessionForEventId(store, eventId, title);
     openNew({ type: "sessions", id: sessionId });
-  }, [store, eventId, eventRow?.title, openNew]);
+  }, [store, eventId, event?.title, openNew]);
 
   if (!event) {
     return null;
diff --git a/apps/desktop/src/calendar/components/oauth/calendar-selection.tsx b/apps/desktop/src/calendar/components/oauth/calendar-selection.tsx
index 1736ada955..e7aa5dd620 100644
--- a/apps/desktop/src/calendar/components/oauth/calendar-selection.tsx
+++ b/apps/desktop/src/calendar/components/oauth/calendar-selection.tsx
@@ -9,7 +9,7 @@ import {
   CalendarSelection,
 } from "~/calendar/components/calendar-selection";
 import type { CalendarProvider } from "~/calendar/components/shared";
-import * as main from "~/store/tinybase/store/main";
+import { useCalendars, useToggleCalendarEnabled } from "~/calendar/queries";
 
 export function OAuthCalendarSelection({
   groups,
@@ -34,33 +34,32 @@ export function OAuthCalendarSelection({
 
 export function useOAuthCalendarSelection(config: CalendarProvider) {
   const queryClient = useQueryClient();
-  const store = main.UI.useStore(main.STORE_ID);
-  const calendars = main.UI.useTable("calendars", main.STORE_ID);
+  const allCalendars = useCalendars();
+  const toggleEnabled = useToggleCalendarEnabled();
   const { cancelDebouncedSync, status, scheduleDebouncedSync, scheduleSync } =
     useSync();
 
   const { groups, connectionSourceMap } = useMemo(() => {
-    const providerCalendars = Object.entries(calendars).filter(
-      ([_, cal]) => cal.provider === config.id,
+    const providerCalendars = allCalendars.filter(
+      (cal) => cal.provider === config.id,
     );
 
     const sourceMap = new Map<string, string>();
 
-    for (const [_, cal] of providerCalendars) {
-      // HACK: derive connection_id -> source mapping from calendar entries
-      if (cal.source && cal.connection_id) {
-        sourceMap.set(cal.connection_id as string, cal.source as string);
+    for (const cal of providerCalendars) {
+      if (cal.source && cal.connectionId) {
+        sourceMap.set(cal.connectionId, cal.source);
       }
     }
 
     const nonNullSources = new Set(
       providerCalendars
-        .map(([_, cal]) => {
+        .map((cal) => {
           if (cal.source) {
             return cal.source;
           }
-          if (cal.connection_id) {
-            return sourceMap.get(cal.connection_id as string);
+          if (cal.connectionId) {
+            return sourceMap.get(cal.connectionId);
           }
           return undefined;
         })
@@ -74,9 +73,8 @@ export function useOAuthCalendarSelection(config: CalendarProvider) {
       { connectionId?: string; calendars: CalendarItem[] }
     >();
 
-    for (const [id, cal] of providerCalendars) {
-      const connectionId =
-        typeof cal.connection_id === "string" ? cal.connection_id : undefined;
+    for (const cal of providerCalendars) {
+      const connectionId = cal.connectionId || undefined;
       const source =
         cal.source ||
         (connectionId ? sourceMap.get(connectionId) : undefined) ||
@@ -90,7 +88,7 @@ export function useOAuthCalendarSelection(config: CalendarProvider) {
         group.connectionId = connectionId;
       }
       group.calendars.push({
-        id,
+        id: cal.id,
         title: cal.name ?? "Untitled",
         color: cal.color ?? "#4285f4",
         enabled: cal.enabled ?? false,
@@ -105,14 +103,14 @@ export function useOAuthCalendarSelection(config: CalendarProvider) {
       })),
       connectionSourceMap: sourceMap,
     };
-  }, [calendars, config.id]);
+  }, [allCalendars, config.id]);
 
   const handleToggle = useCallback(
     (calendar: CalendarItem, enabled: boolean) => {
-      store?.setPartialRow("calendars", calendar.id, { enabled });
+      void toggleEnabled(calendar.id, enabled);
       scheduleDebouncedSync();
     },
-    [store, scheduleDebouncedSync],
+    [toggleEnabled, scheduleDebouncedSync],
   );
 
   const handleRefresh = useCallback(() => {
diff --git a/apps/desktop/src/calendar/hooks.ts b/apps/desktop/src/calendar/hooks.ts
index d97b0ecefa..4316d3cc87 100644
--- a/apps/desktop/src/calendar/hooks.ts
+++ b/apps/desktop/src/calendar/hooks.ts
@@ -4,6 +4,7 @@ import { useEffect, useMemo, useState } from "react";
 import { safeParseDate } from "@hypr/utils";
 import { TZDate } from "@hypr/utils";
 
+import { useTimelineEvents } from "~/calendar/queries";
 import { useConfigValue } from "~/shared/config";
 import { useIgnoredEvents } from "~/store/tinybase/hooks";
 import * as main from "~/store/tinybase/store/main";
@@ -70,10 +71,7 @@ function compareNullableDates(a: string | undefined, b: string | undefined) {
 export function useCalendarData(): CalendarData {
   const tz = useTimezone();
 
-  const eventsTable = main.UI.useResultTable(
-    main.QUERIES.timelineEvents,
-    main.STORE_ID,
-  );
+  const eventsTable = useTimelineEvents();
   const sessionsTable = main.UI.useResultTable(
     main.QUERIES.timelineSessions,
     main.STORE_ID,
diff --git a/apps/desktop/src/calendar/queries.ts b/apps/desktop/src/calendar/queries.ts
new file mode 100644
index 0000000000..e6fe26cec7
--- /dev/null
+++ b/apps/desktop/src/calendar/queries.ts
@@ -0,0 +1,536 @@
+import { useMutation } from "@tanstack/react-query";
+import { useCallback } from "react";
+
+import { and, calendars, eq, events, gte, inArray, lte, sql } from "@hypr/db";
+
+import { db, useDrizzleLiveQuery } from "~/db";
+
+// ---------------------------------------------------------------------------
+// Live-row types (raw SQLite column names, snake_case)
+// ---------------------------------------------------------------------------
+
+type CalendarLiveRow = {
+  id: string;
+  tracking_id_calendar: string;
+  name: string;
+  enabled: number | boolean;
+  provider: string;
+  source: string;
+  color: string;
+  connection_id: string;
+  created_at: string;
+  updated_at: string;
+};
+
+type EventLiveRow = {
+  id: string;
+  tracking_id_event: string;
+  calendar_id: string;
+  title: string;
+  started_at: string;
+  ended_at: string;
+  location: string;
+  meeting_link: string;
+  description: string;
+  note: string;
+  recurrence_series_id: string;
+  has_recurrence_rules: number | boolean;
+  is_all_day: number | boolean;
+  provider: string;
+  participants_json: unknown;
+  created_at: string;
+  updated_at: string;
+};
+
+// ---------------------------------------------------------------------------
+// Domain types (camelCase, parsed)
+// ---------------------------------------------------------------------------
+
+export type CalendarRecord = {
+  id: string;
+  trackingIdCalendar: string;
+  name: string;
+  enabled: boolean;
+  provider: string;
+  source: string;
+  color: string;
+  connectionId: string;
+  createdAt: string;
+};
+
+export type EventRecord = {
+  id: string;
+  trackingIdEvent: string;
+  calendarId: string;
+  title: string;
+  startedAt: string;
+  endedAt: string;
+  location: string;
+  meetingLink: string;
+  description: string;
+  note: string;
+  recurrenceSeriesId: string;
+  hasRecurrenceRules: boolean;
+  isAllDay: boolean;
+  provider: string;
+  participantsJson: unknown;
+  createdAt: string;
+};
+
+// ---------------------------------------------------------------------------
+// Row mappers
+// ---------------------------------------------------------------------------
+
+function mapCalendarLiveRow(row: CalendarLiveRow): CalendarRecord {
+  return {
+    id: row.id,
+    trackingIdCalendar: row.tracking_id_calendar,
+    name: row.name,
+    enabled: Boolean(row.enabled),
+    provider: row.provider,
+    source: row.source,
+    color: row.color,
+    connectionId: row.connection_id,
+    createdAt: row.created_at,
+  };
+}
+
+function mapCalendarLiveRows(rows: CalendarLiveRow[]): CalendarRecord[] {
+  return rows.map(mapCalendarLiveRow);
+}
+
+function mapEventLiveRow(row: EventLiveRow): EventRecord {
+  return {
+    id: row.id,
+    trackingIdEvent: row.tracking_id_event,
+    calendarId: row.calendar_id,
+    title: row.title,
+    startedAt: row.started_at,
+    endedAt: row.ended_at,
+    location: row.location,
+    meetingLink: row.meeting_link,
+    description: row.description,
+    note: row.note,
+    recurrenceSeriesId: row.recurrence_series_id,
+    hasRecurrenceRules: Boolean(row.has_recurrence_rules),
+    isAllDay: Boolean(row.is_all_day),
+    provider: row.provider,
+    participantsJson: row.participants_json,
+    createdAt: row.created_at,
+  };
+}
+
+function mapEventLiveRows(rows: EventLiveRow[]): EventRecord[] {
+  return rows.map(mapEventLiveRow);
+}
+
+// ---------------------------------------------------------------------------
+// Reactive hooks — calendars
+// ---------------------------------------------------------------------------
+
+export function useCalendars(): CalendarRecord[] {
+  const query = db.select().from(calendars).orderBy(calendars.name);
+  const { data = [] } = useDrizzleLiveQuery<CalendarLiveRow, CalendarRecord[]>(
+    query,
+    { mapRows: mapCalendarLiveRows },
+  );
+  return data;
+}
+
+export function useEnabledCalendars(): CalendarRecord[] {
+  const query = db
+    .select()
+    .from(calendars)
+    .where(eq(calendars.enabled, true))
+    .orderBy(calendars.name);
+  const { data = [] } = useDrizzleLiveQuery<CalendarLiveRow, CalendarRecord[]>(
+    query,
+    { mapRows: mapCalendarLiveRows },
+  );
+  return data;
+}
+
+export function useCalendarById(
+  id: string | null | undefined,
+): CalendarRecord | null {
+  const query = db
+    .select()
+    .from(calendars)
+    .where(eq(calendars.id, id ?? ""))
+    .limit(1);
+  const { data = null } = useDrizzleLiveQuery<
+    CalendarLiveRow,
+    CalendarRecord | null
+  >(query, {
+    mapRows: (rows) => (rows.length > 0 ? mapCalendarLiveRow(rows[0]) : null),
+  });
+  return data;
+}
+
+// ---------------------------------------------------------------------------
+// Reactive hooks — events
+// ---------------------------------------------------------------------------
+
+export function useEventById(eventId: string | undefined): EventRecord | null {
+  const query = db
+    .select()
+    .from(events)
+    .where(eq(events.id, eventId ?? ""))
+    .limit(1);
+  const { data = null } = useDrizzleLiveQuery<EventLiveRow, EventRecord | null>(
+    query,
+    {
+      mapRows: (rows) => (rows.length > 0 ? mapEventLiveRow(rows[0]) : null),
+      enabled: !!eventId,
+    },
+  );
+  return data;
+}
+
+export function useAllEvents(): EventRecord[] {
+  const query = db.select().from(events).orderBy(events.startedAt);
+  const { data = [] } = useDrizzleLiveQuery<EventLiveRow, EventRecord[]>(
+    query,
+    { mapRows: mapEventLiveRows },
+  );
+  return data;
+}
+
+type TimelineEventRow = {
+  id: string;
+  title: string;
+  started_at: string;
+  ended_at: string;
+  calendar_id: string;
+  tracking_id_event: string;
+  has_recurrence_rules: boolean;
+  recurrence_series_id: string;
+  is_all_day: boolean;
+};
+
+export function useTimelineEvents(): Record<string, TimelineEventRow> | null {
+  const query = db.select().from(events);
+  const { data = null } = useDrizzleLiveQuery<
+    EventLiveRow,
+    Record<string, TimelineEventRow> | null
+  >(query, {
+    mapRows: (rows) => {
+      if (rows.length === 0) return null;
+      const result: Record<string, TimelineEventRow> = {};
+      for (const row of rows) {
+        result[row.id] = {
+          id: row.id,
+          title: row.title,
+          started_at: row.started_at,
+          ended_at: row.ended_at,
+          calendar_id: row.calendar_id,
+          tracking_id_event: row.tracking_id_event,
+          has_recurrence_rules: Boolean(row.has_recurrence_rules),
+          recurrence_series_id: row.recurrence_series_id,
+          is_all_day: Boolean(row.is_all_day),
+        };
+      }
+      return result;
+    },
+  });
+  return data;
+}
+
+// ---------------------------------------------------------------------------
+// Imperative reads
+// ---------------------------------------------------------------------------
+
+export async function getEnabledCalendars(): Promise<CalendarRecord[]> {
+  const rows = await db
+    .select()
+    .from(calendars)
+    .where(eq(calendars.enabled, true));
+  return rows.map((row) => ({
+    id: row.id,
+    trackingIdCalendar: row.trackingIdCalendar,
+    name: row.name,
+    enabled: row.enabled,
+    provider: row.provider,
+    source: row.source,
+    color: row.color,
+    connectionId: row.connectionId,
+    createdAt: row.createdAt,
+  }));
+}
+
+export async function getAllCalendars(): Promise<CalendarRecord[]> {
+  const rows = await db.select().from(calendars);
+  return rows.map((row) => ({
+    id: row.id,
+    trackingIdCalendar: row.trackingIdCalendar,
+    name: row.name,
+    enabled: row.enabled,
+    provider: row.provider,
+    source: row.source,
+    color: row.color,
+    connectionId: row.connectionId,
+    createdAt: row.createdAt,
+  }));
+}
+
+export async function getCalendarById(
+  id: string,
+): Promise<CalendarRecord | null> {
+  const rows = await db
+    .select()
+    .from(calendars)
+    .where(eq(calendars.id, id))
+    .limit(1);
+  if (rows.length === 0) return null;
+  const row = rows[0];
+  return {
+    id: row.id,
+    trackingIdCalendar: row.trackingIdCalendar,
+    name: row.name,
+    enabled: row.enabled,
+    provider: row.provider,
+    source: row.source,
+    color: row.color,
+    connectionId: row.connectionId,
+    createdAt: row.createdAt,
+  };
+}
+
+export async function getEventById(id: string): Promise<EventRecord | null> {
+  const rows = await db.select().from(events).where(eq(events.id, id)).limit(1);
+  if (rows.length === 0) return null;
+  const row = rows[0];
+  return {
+    id: row.id,
+    trackingIdEvent: row.trackingIdEvent,
+    calendarId: row.calendarId,
+    title: row.title,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    location: row.location,
+    meetingLink: row.meetingLink,
+    description: row.description,
+    note: row.note,
+    recurrenceSeriesId: row.recurrenceSeriesId,
+    hasRecurrenceRules: row.hasRecurrenceRules,
+    isAllDay: row.isAllDay,
+    provider: row.provider,
+    participantsJson: row.participantsJson,
+    createdAt: row.createdAt,
+  };
+}
+
+export async function eventExists(id: string): Promise<boolean> {
+  const rows = await db
+    .select({ id: events.id })
+    .from(events)
+    .where(eq(events.id, id))
+    .limit(1);
+  return rows.length > 0;
+}
+
+export async function getEventsByCalendarIds(
+  calendarIds: string[],
+  from: string,
+  to: string,
+): Promise<EventRecord[]> {
+  if (calendarIds.length === 0) return [];
+  const rows = await db
+    .select()
+    .from(events)
+    .where(
+      and(
+        inArray(events.calendarId, calendarIds),
+        gte(events.startedAt, from),
+        lte(events.startedAt, to),
+      ),
+    );
+  return rows.map((row) => ({
+    id: row.id,
+    trackingIdEvent: row.trackingIdEvent,
+    calendarId: row.calendarId,
+    title: row.title,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    location: row.location,
+    meetingLink: row.meetingLink,
+    description: row.description,
+    note: row.note,
+    recurrenceSeriesId: row.recurrenceSeriesId,
+    hasRecurrenceRules: row.hasRecurrenceRules,
+    isAllDay: row.isAllDay,
+    provider: row.provider,
+    participantsJson: row.participantsJson,
+    createdAt: row.createdAt,
+  }));
+}
+
+export async function getAllEvents(): Promise<EventRecord[]> {
+  const rows = await db.select().from(events);
+  return rows.map((row) => ({
+    id: row.id,
+    trackingIdEvent: row.trackingIdEvent,
+    calendarId: row.calendarId,
+    title: row.title,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    location: row.location,
+    meetingLink: row.meetingLink,
+    description: row.description,
+    note: row.note,
+    recurrenceSeriesId: row.recurrenceSeriesId,
+    hasRecurrenceRules: row.hasRecurrenceRules,
+    isAllDay: row.isAllDay,
+    provider: row.provider,
+    participantsJson: row.participantsJson,
+    createdAt: row.createdAt,
+  }));
+}
+
+// ---------------------------------------------------------------------------
+// Writes
+// ---------------------------------------------------------------------------
+
+export async function insertCalendar(cal: {
+  id: string;
+  trackingIdCalendar: string;
+  name: string;
+  enabled: boolean;
+  provider: string;
+  source: string;
+  color: string;
+  connectionId: string;
+  createdAt?: string;
+}): Promise<void> {
+  await db.insert(calendars).values({
+    id: cal.id,
+    trackingIdCalendar: cal.trackingIdCalendar,
+    name: cal.name,
+    enabled: cal.enabled,
+    provider: cal.provider,
+    source: cal.source,
+    color: cal.color,
+    connectionId: cal.connectionId,
+    createdAt: cal.createdAt ?? sql`strftime('%Y-%m-%dT%H:%M:%SZ', 'now')`,
+    updatedAt: sql`strftime('%Y-%m-%dT%H:%M:%SZ', 'now')`,
+  });
+}
+
+export async function updateCalendar(
+  id: string,
+  fields: Partial<{
+    trackingIdCalendar: string;
+    name: string;
+    enabled: boolean;
+    provider: string;
+    source: string;
+    color: string;
+    connectionId: string;
+  }>,
+): Promise<void> {
+  await db
+    .update(calendars)
+    .set({
+      ...fields,
+      updatedAt: sql`strftime('%Y-%m-%dT%H:%M:%SZ', 'now')`,
+    })
+    .where(eq(calendars.id, id));
+}
+
+export async function deleteCalendar(id: string): Promise<void> {
+  await db.delete(calendars).where(eq(calendars.id, id));
+}
+
+export async function insertEvent(evt: {
+  id: string;
+  trackingIdEvent: string;
+  calendarId: string;
+  title: string;
+  startedAt: string;
+  endedAt: string;
+  location: string;
+  meetingLink: string;
+  description: string;
+  note?: string;
+  recurrenceSeriesId: string;
+  hasRecurrenceRules: boolean;
+  isAllDay: boolean;
+  provider: string;
+  participantsJson?: unknown;
+  createdAt?: string;
+}): Promise<void> {
+  await db.insert(events).values({
+    id: evt.id,
+    trackingIdEvent: evt.trackingIdEvent,
+    calendarId: evt.calendarId,
+    title: evt.title,
+    startedAt: evt.startedAt,
+    endedAt: evt.endedAt,
+    location: evt.location,
+    meetingLink: evt.meetingLink,
+    description: evt.description,
+    note: evt.note ?? "",
+    recurrenceSeriesId: evt.recurrenceSeriesId,
+    hasRecurrenceRules: evt.hasRecurrenceRules,
+    isAllDay: evt.isAllDay,
+    provider: evt.provider,
+    participantsJson: evt.participantsJson ?? null,
+    createdAt: evt.createdAt ?? sql`strftime('%Y-%m-%dT%H:%M:%SZ', 'now')`,
+    updatedAt: sql`strftime('%Y-%m-%dT%H:%M:%SZ', 'now')`,
+  });
+}
+
+export async function updateEvent(
+  id: string,
+  fields: Partial<{
+    trackingIdEvent: string;
+    calendarId: string;
+    title: string;
+    startedAt: string;
+    endedAt: string;
+    location: string;
+    meetingLink: string;
+    description: string;
+    note: string;
+    recurrenceSeriesId: string;
+    hasRecurrenceRules: boolean;
+    isAllDay: boolean;
+    provider: string;
+    participantsJson: unknown;
+  }>,
+): Promise<void> {
+  await db
+    .update(events)
+    .set({
+      ...fields,
+      updatedAt: sql`strftime('%Y-%m-%dT%H:%M:%SZ', 'now')`,
+    })
+    .where(eq(events.id, id));
+}
+
+export async function deleteEvent(id: string): Promise<void> {
+  await db.delete(events).where(eq(events.id, id));
+}
+
+export async function deleteEventsByCalendarId(
+  calendarId: string,
+): Promise<void> {
+  await db.delete(events).where(eq(events.calendarId, calendarId));
+}
+
+// ---------------------------------------------------------------------------
+// Mutation hooks
+// ---------------------------------------------------------------------------
+
+export function useToggleCalendarEnabled() {
+  const mutation = useMutation({
+    mutationFn: async ({ id, enabled }: { id: string; enabled: boolean }) => {
+      await updateCalendar(id, { enabled });
+    },
+  });
+
+  return useCallback(
+    (id: string, enabled: boolean) => mutation.mutateAsync({ id, enabled }),
+    [mutation],
+  );
+}
diff --git a/apps/desktop/src/calendar/utils.ts b/apps/desktop/src/calendar/utils.ts
index c7781f28e1..55ea7a3243 100644
--- a/apps/desktop/src/calendar/utils.ts
+++ b/apps/desktop/src/calendar/utils.ts
@@ -1,6 +1,4 @@
-import type { Store } from "tinybase/with-schemas";
-
-import type { Schemas } from "~/store/tinybase/store/main";
+import { getAllCalendars } from "~/calendar/queries";
 
 export function getCalendarTrackingKey({
   provider,
@@ -14,31 +12,26 @@ export function getCalendarTrackingKey({
   return [provider ?? "", connectionId ?? "", trackingId ?? ""].join(":");
 }
 
-export function findCalendarByTrackingId(
-  store: Store<Schemas>,
-  {
-    provider,
-    connectionId,
-    trackingId,
-  }: {
-    provider: string;
-    connectionId: string;
-    trackingId: string;
-  },
-): string | null {
-  let foundRowId: string | null = null;
+export async function findCalendarByTrackingId({
+  provider,
+  connectionId,
+  trackingId,
+}: {
+  provider: string;
+  connectionId: string;
+  trackingId: string;
+}): Promise<string | null> {
+  const calendars = await getAllCalendars();
 
-  store.forEachRow("calendars", (rowId, _forEachCell) => {
-    if (foundRowId) return;
-    const row = store.getRow("calendars", rowId);
+  for (const cal of calendars) {
     if (
-      row?.provider === provider &&
-      row?.connection_id === connectionId &&
-      row?.tracking_id_calendar === trackingId
+      cal.provider === provider &&
+      cal.connectionId === connectionId &&
+      cal.trackingIdCalendar === trackingId
     ) {
-      foundRowId = rowId;
+      return cal.id;
     }
-  });
+  }
 
-  return foundRowId;
+  return null;
 }
diff --git a/apps/desktop/src/main/lifecycle.tsx b/apps/desktop/src/main/lifecycle.tsx
index 17361d45f6..f224615771 100644
--- a/apps/desktop/src/main/lifecycle.tsx
+++ b/apps/desktop/src/main/lifecycle.tsx
@@ -2,6 +2,7 @@ import { useRouteContext } from "@tanstack/react-router";
 import { useCallback, useEffect, useRef } from "react";
 
 import { useLanguageModel, useLLMConnection } from "~/ai/hooks";
+import { getAllEvents } from "~/calendar/queries";
 import { useSessionTab } from "~/chat/components/use-session-tab";
 import { buildChatTools } from "~/chat/tools";
 import { useRegisterTools } from "~/contexts/tool";
@@ -142,6 +143,8 @@ function ToolRegistration() {
         sessionByTrackingId.set(event.tracking_id, sessionId);
       });
 
+      const allEvents = await getAllEvents();
+
       const rows: Array<{
         id: string;
         title: string;
@@ -155,45 +158,23 @@ function ToolRegistration() {
         startedAtMs: number;
       }> = [];
 
-      store.forEachRow("events", (eventId, _forEachCell) => {
-        const row = store.getRow("events", eventId);
-        if (!row) {
-          return;
-        }
-
-        const title = typeof row.title === "string" ? row.title : "";
-        const startedAt =
-          typeof row.started_at === "string" && row.started_at
-            ? row.started_at
-            : null;
-        const endedAt =
-          typeof row.ended_at === "string" && row.ended_at
-            ? row.ended_at
-            : null;
-        const location =
-          typeof row.location === "string" && row.location
-            ? row.location
-            : null;
-        const meetingLink =
-          typeof row.meeting_link === "string" && row.meeting_link
-            ? row.meeting_link
-            : null;
-        const description =
-          typeof row.description === "string" && row.description
-            ? row.description
-            : null;
-        const trackingId =
-          typeof row.tracking_id_event === "string"
-            ? row.tracking_id_event
-            : "";
+      for (const evt of allEvents) {
+        const title = evt.title || "";
+        const startedAt = evt.startedAt || null;
+        const endedAt = evt.endedAt || null;
+        const location = evt.location || null;
+        const meetingLink = evt.meetingLink || null;
+        const description = evt.description || null;
+        const trackingId = evt.trackingIdEvent || "";
 
         let participantCount = 0;
-        if (
-          typeof row.participants_json === "string" &&
-          row.participants_json
-        ) {
+        if (evt.participantsJson) {
           try {
-            const parsed = JSON.parse(row.participants_json);
+            const raw =
+              typeof evt.participantsJson === "string"
+                ? evt.participantsJson
+                : JSON.stringify(evt.participantsJson);
+            const parsed = JSON.parse(raw);
             if (Array.isArray(parsed)) {
               participantCount = parsed.length;
             }
@@ -206,11 +187,11 @@ function ToolRegistration() {
           .toLowerCase();
 
         if (q && !searchable.includes(q)) {
-          return;
+          continue;
         }
 
         rows.push({
-          id: eventId,
+          id: evt.id,
           title: title || "Untitled event",
           startedAt,
           endedAt,
@@ -221,7 +202,7 @@ function ToolRegistration() {
           linkedSessionId: sessionByTrackingId.get(trackingId) ?? null,
           startedAtMs: startedAt ? Date.parse(startedAt) || 0 : 0,
         });
-      });
+      }
 
       rows.sort((a, b) => b.startedAtMs - a.startedAtMs);
 
diff --git a/apps/desktop/src/main2/home/note-editor.tsx b/apps/desktop/src/main2/home/note-editor.tsx
index e93c4cd195..99e93f2665 100644
--- a/apps/desktop/src/main2/home/note-editor.tsx
+++ b/apps/desktop/src/main2/home/note-editor.tsx
@@ -2,12 +2,13 @@ import "./note-editor.css";
 
 import { Node as PMNode } from "prosemirror-model";
 import type { EditorView } from "prosemirror-view";
-import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 import { parseJsonContent } from "@hypr/tiptap/shared";
 import { format, parseISO, subDays } from "@hypr/utils";
 
 import { useCalendarData } from "~/calendar/hooks";
+import { getEventById } from "~/calendar/queries";
 import {
   type JSONContent,
   NoteEditor,
@@ -41,23 +42,23 @@ function getSessionTitle(store: Store, sessionId: string): string {
   return typeof title === "string" ? title : "";
 }
 
-function resolveEventSessionId(
+async function resolveEventSessionId(
   store: Store,
   eventId: string,
   createMissing = false,
-): string | null {
-  const existingSessionId = findSessionByEventId(store, eventId);
+): Promise<string | null> {
+  const existingSessionId = await findSessionByEventId(store, eventId);
   if (existingSessionId) {
     return existingSessionId;
   }
 
-  const event = store.getRow("events", eventId);
+  const event = await getEventById(eventId);
   if (!event) {
     return null;
   }
 
   return createMissing
-    ? getOrCreateSessionForEventId(store, eventId, event.title as string)
+    ? getOrCreateSessionForEventId(store, eventId, event.title)
     : null;
 }
 
@@ -70,9 +71,20 @@ function normalizeSessionId(store: Store, sessionId: string): string {
   return findSessionByTrackingId(store, trackingId) ?? sessionId;
 }
 
-function buildLinkedSessionIds(
+async function buildEventSessionMap(
   store: Store,
   eventIds: string[],
+): Promise<Map<string, string | null>> {
+  const map = new Map<string, string | null>();
+  for (const eventId of eventIds) {
+    map.set(eventId, await resolveEventSessionId(store, eventId));
+  }
+  return map;
+}
+
+function buildLinkedSessionIds(
+  store: Store,
+  eventSessionMap: Map<string, string | null>,
   sessionIds: string[],
 ): string[] {
   const linkedSessionIds: string[] = [];
@@ -92,8 +104,8 @@ function buildLinkedSessionIds(
     linkedSessionIds.push(normalizedSessionId);
   };
 
-  for (const eventId of eventIds) {
-    pushSessionId(resolveEventSessionId(store, eventId));
+  for (const [, sessionId] of eventSessionMap) {
+    pushSessionId(sessionId);
   }
 
   for (const sessionId of sessionIds) {
@@ -108,37 +120,44 @@ function buildLinkedContent(
   content: JSONContent,
   eventIds: string[],
   sessionIds: string[],
+  eventSessionMap: Map<string, string | null>,
 ): JSONContent {
-  const linkedSessionIds = buildLinkedSessionIds(store, eventIds, sessionIds);
+  const linkedSessionIds = buildLinkedSessionIds(
+    store,
+    eventSessionMap,
+    sessionIds,
+  );
   const linkedSessionIdSet = new Set(linkedSessionIds);
 
   return mergeLinkedSessionsIntoContent({
     content,
     eventIds,
     sessionIds,
-    resolveEventSessionId: (eventId) => resolveEventSessionId(store, eventId),
+    resolveEventSessionId: (eventId) => eventSessionMap.get(eventId) ?? null,
     getSessionTitle: (sessionId) => getSessionTitle(store, sessionId),
     normalizeSessionId: (sessionId) => normalizeSessionId(store, sessionId),
     keepLinkedSession: (sessionId) => linkedSessionIdSet.has(sessionId),
   });
 }
 
-function syncLinkedSessions(
+async function syncLinkedSessions(
   view: EditorView,
   store: Store,
   eventIds: string[],
   sessionIds: string[],
-): boolean {
+): Promise<boolean> {
   for (const eventId of eventIds) {
-    resolveEventSessionId(store, eventId, true);
+    await resolveEventSessionId(store, eventId, true);
   }
 
+  const eventSessionMap = await buildEventSessionMap(store, eventIds);
   const currentContent = view.state.doc.toJSON() as JSONContent;
   const nextContent = buildLinkedContent(
     store,
     currentContent,
     eventIds,
     sessionIds,
+    eventSessionMap,
   );
   if (JSON.stringify(nextContent) === JSON.stringify(currentContent)) {
     return false;
@@ -190,90 +209,108 @@ export function DailyNoteEditor({
   const eventIds = eventIdsByDate[date] ?? [];
   const sessionIds = sessionIdsByDate[date] ?? [];
 
-  // Compute initial content once on mount — imperative read, no subscription.
+  // Compute initial content once on mount via async init.
   // This breaks the read→derive→write→read loop that `useCell` would create.
-  const initialContentRef = useRef<JSONContent | null>(null);
-  if (!initialContentRef.current && store) {
-    for (const eventId of eventIds) {
-      resolveEventSessionId(store, eventId, true);
-    }
+  const [initialContent, setInitialContent] = useState<JSONContent | null>(
+    null,
+  );
+  const initStartedRef = useRef(false);
+  useEffect(() => {
+    if (initStartedRef.current || !store) return;
+    initStartedRef.current = true;
 
-    const rawContent = readRawContent(store, date);
-    const linked = buildLinkedContent(store, rawContent, eventIds, sessionIds);
-
-    let content = linked;
-    if (isToday && taskStorage) {
-      const rawPrevious = readRawContent(store, previousDate);
-      const currentCanonicalTasks = taskStorage.getTasksForSource(taskSource);
-      const previousCanonicalTasks =
-        taskStorage.getTasksForSource(previousTaskSource);
-
-      const hydratedCurrent =
-        currentCanonicalTasks.length > 0
-          ? hydrateTaskContent({
-              content: linked,
-              sourceTasks: currentCanonicalTasks,
-              getTask: taskStorage.getTask,
-            })
-          : linked;
-      const hydratedPrevious =
-        previousCanonicalTasks.length > 0
-          ? hydrateTaskContent({
-              content: rawPrevious,
-              sourceTasks: previousCanonicalTasks,
-              getTask: taskStorage.getTask,
-            })
-          : rawPrevious;
-
-      const currentTasks =
-        currentCanonicalTasks.length > 0
-          ? currentCanonicalTasks
-          : extractTasksFromContent(hydratedCurrent, taskSource);
-      const previousTasks =
-        previousCanonicalTasks.length > 0
-          ? previousCanonicalTasks
-          : extractTasksFromContent(hydratedPrevious, previousTaskSource);
-
-      const carryForward = moveOpenTasksBetweenContents({
-        previousContent: hydratedPrevious,
-        currentContent: hydratedCurrent,
-        previousTasks,
-        currentTasks,
-        currentSource: taskSource,
-      });
-
-      if (carryForward) {
-        content = carryForward.currentContent;
-        taskStorage.upsertTasksForSource(taskSource, carryForward.currentTasks);
-        taskStorage.upsertTasksForSource(
-          previousTaskSource,
-          carryForward.previousTasks,
-        );
-
-        if (
-          JSON.stringify(carryForward.previousContent) !==
-          JSON.stringify(rawPrevious)
-        ) {
-          store.setPartialRow("daily_notes", previousDate, {
-            date: previousDate,
-            content: JSON.stringify(carryForward.previousContent),
-          });
+    (async () => {
+      for (const eventId of eventIds) {
+        await resolveEventSessionId(store, eventId, true);
+      }
+
+      const eventSessionMap = await buildEventSessionMap(store, eventIds);
+      const rawContent = readRawContent(store, date);
+      const linked = buildLinkedContent(
+        store,
+        rawContent,
+        eventIds,
+        sessionIds,
+        eventSessionMap,
+      );
+
+      let content = linked;
+      if (isToday && taskStorage) {
+        const rawPrevious = readRawContent(store, previousDate);
+        const currentCanonicalTasks = taskStorage.getTasksForSource(taskSource);
+        const previousCanonicalTasks =
+          taskStorage.getTasksForSource(previousTaskSource);
+
+        const hydratedCurrent =
+          currentCanonicalTasks.length > 0
+            ? hydrateTaskContent({
+                content: linked,
+                sourceTasks: currentCanonicalTasks,
+                getTask: taskStorage.getTask,
+              })
+            : linked;
+        const hydratedPrevious =
+          previousCanonicalTasks.length > 0
+            ? hydrateTaskContent({
+                content: rawPrevious,
+                sourceTasks: previousCanonicalTasks,
+                getTask: taskStorage.getTask,
+              })
+            : rawPrevious;
+
+        const currentTasks =
+          currentCanonicalTasks.length > 0
+            ? currentCanonicalTasks
+            : extractTasksFromContent(hydratedCurrent, taskSource);
+        const previousTasks =
+          previousCanonicalTasks.length > 0
+            ? previousCanonicalTasks
+            : extractTasksFromContent(hydratedPrevious, previousTaskSource);
+
+        const carryForward = moveOpenTasksBetweenContents({
+          previousContent: hydratedPrevious,
+          currentContent: hydratedCurrent,
+          previousTasks,
+          currentTasks,
+          currentSource: taskSource,
+        });
+
+        if (carryForward) {
+          content = carryForward.currentContent;
+          taskStorage.upsertTasksForSource(
+            taskSource,
+            carryForward.currentTasks,
+          );
+          taskStorage.upsertTasksForSource(
+            previousTaskSource,
+            carryForward.previousTasks,
+          );
+
+          if (
+            JSON.stringify(carryForward.previousContent) !==
+            JSON.stringify(rawPrevious)
+          ) {
+            store.setPartialRow("daily_notes", previousDate, {
+              date: previousDate,
+              content: JSON.stringify(carryForward.previousContent),
+            });
+          }
+        } else {
+          taskStorage.upsertTasksForSource(taskSource, currentTasks);
+          taskStorage.upsertTasksForSource(previousTaskSource, previousTasks);
         }
-      } else {
-        taskStorage.upsertTasksForSource(taskSource, currentTasks);
-        taskStorage.upsertTasksForSource(previousTaskSource, previousTasks);
       }
-    }
 
-    if (JSON.stringify(content) !== JSON.stringify(rawContent)) {
-      store.setPartialRow("daily_notes", date, {
-        date,
-        content: JSON.stringify(content),
-      });
-    }
+      if (JSON.stringify(content) !== JSON.stringify(rawContent)) {
+        store.setPartialRow("daily_notes", date, {
+          date,
+          content: JSON.stringify(content),
+        });
+      }
 
-    initialContentRef.current = content;
-  }
+      setInitialContent(content);
+    })();
+  }, [store]);
 
   const persistDailyNote = main.UI.useSetPartialRowCallback(
     "daily_notes",
@@ -289,11 +326,9 @@ export function DailyNoteEditor({
       return;
     }
 
-    try {
-      syncLinkedSessions(view, store, eventIds, sessionIds);
-    } catch {
+    void syncLinkedSessions(view, store, eventIds, sessionIds).catch(() => {
       // invalid content
-    }
+    });
   }, [eventIds, sessionIds, store]);
 
   const handleChange = useCallback(
@@ -349,7 +384,7 @@ export function DailyNoteEditor({
     [focusEditor],
   );
 
-  if (!initialContentRef.current) {
+  if (!initialContent) {
     return null;
   }
 
@@ -362,7 +397,7 @@ export function DailyNoteEditor({
       <NoteEditor
         ref={editorRef}
         key={`daily-${date}`}
-        initialContent={initialContentRef.current}
+        initialContent={initialContent}
         handleChange={handleChange}
         linkedItemOpenBehavior="new"
         taskSource={taskSource}
diff --git a/apps/desktop/src/onboarding/calendar.tsx b/apps/desktop/src/onboarding/calendar.tsx
index 46d3ca2ee6..1ff6fcc12c 100644
--- a/apps/desktop/src/onboarding/calendar.tsx
+++ b/apps/desktop/src/onboarding/calendar.tsx
@@ -20,10 +20,10 @@ import { SyncProvider, useSync } from "~/calendar/components/context";
 import { useOAuthCalendarSelection } from "~/calendar/components/oauth/calendar-selection";
 import { ReconnectRequiredIndicator } from "~/calendar/components/oauth/status";
 import { PROVIDERS } from "~/calendar/components/shared";
+import { useEnabledCalendars } from "~/calendar/queries";
 import { useMountEffect } from "~/shared/hooks/useMountEffect";
 import { usePermission } from "~/shared/hooks/usePermissions";
 import { buildWebAppUrl } from "~/shared/utils";
-import * as main from "~/store/tinybase/store/main";
 
 const GOOGLE_PROVIDER = PROVIDERS.find((provider) => provider.id === "google");
 const OUTLOOK_PROVIDER = PROVIDERS.find(
@@ -548,11 +548,8 @@ function CalendarSectionContent({
   const calendar = usePermission("calendar");
   const isAuthorized = calendar.status === "authorized";
   const [showTroubleshooting, setShowTroubleshooting] = useState(false);
-  const enabledCalendars = main.UI.useResultTable(
-    main.QUERIES.enabledCalendars,
-    main.STORE_ID,
-  );
-  const hasConnectedCalendar = Object.keys(enabledCalendars ?? {}).length > 0;
+  const enabledCalendars = useEnabledCalendars();
+  const hasConnectedCalendar = enabledCalendars.length > 0;
 
   const hasAnyConnected = hasConnectedCalendar || isAuthorized;
 
diff --git a/apps/desktop/src/services/calendar/ctx.test.ts b/apps/desktop/src/services/calendar/ctx.test.ts
index 7ac5416e37..b90bdaf7c4 100644
--- a/apps/desktop/src/services/calendar/ctx.test.ts
+++ b/apps/desktop/src/services/calendar/ctx.test.ts
@@ -1,8 +1,5 @@
-import { createMergeableStore } from "tinybase/with-schemas";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 
-import { SCHEMA } from "@hypr/store";
-
 const pluginCalendar = vi.hoisted(() => ({
   listCalendars: vi.fn(),
 }));
@@ -13,46 +10,99 @@ vi.mock("@hypr/plugin-calendar", () => ({
   },
 }));
 
-import { syncCalendars } from "./ctx";
-
-function createStore() {
-  const store = createMergeableStore()
-    .setTablesSchema(SCHEMA.table)
-    .setValuesSchema(SCHEMA.value);
+const calendarQueries = vi.hoisted(() => ({
+  getAllCalendars: vi.fn(),
+  getEnabledCalendars: vi.fn(),
+  insertCalendar: vi.fn(),
+  updateCalendar: vi.fn(),
+  deleteCalendar: vi.fn(),
+  deleteEventsByCalendarId: vi.fn(),
+}));
 
-  store.setValue("user_id", "user-1");
+vi.mock("~/calendar/queries", () => calendarQueries);
+
+vi.mock("~/calendar/utils", async (importOriginal) => {
+  const original = await importOriginal<typeof import("~/calendar/utils")>();
+  return {
+    getCalendarTrackingKey: original.getCalendarTrackingKey,
+    findCalendarByTrackingId: vi.fn(
+      async ({ provider, connectionId, trackingId }) => {
+        const calendars = await calendarQueries.getAllCalendars();
+        for (const cal of calendars) {
+          if (
+            cal.provider === provider &&
+            cal.connectionId === connectionId &&
+            cal.trackingIdCalendar === trackingId
+          ) {
+            return cal.id;
+          }
+        }
+        return null;
+      },
+    ),
+  };
+});
 
-  return store;
-}
+import { syncCalendars } from "./ctx";
 
-function getCalendarsByConnection(
-  store: ReturnType<typeof createStore>,
-  provider: string,
-) {
-  return store
-    .getRowIds("calendars")
-    .map((rowId) => ({ id: rowId, ...store.getRow("calendars", rowId) }))
-    .filter((calendar) => calendar.provider === provider);
-}
+type CalRecord = {
+  id: string;
+  trackingIdCalendar: string;
+  name: string;
+  enabled: boolean;
+  provider: string;
+  source: string;
+  color: string;
+  connectionId: string;
+  createdAt: string;
+};
 
 describe("syncCalendars", () => {
+  let calendarsDb: CalRecord[];
+
   beforeEach(() => {
     pluginCalendar.listCalendars.mockReset();
+    calendarsDb = [];
+
+    calendarQueries.getAllCalendars.mockImplementation(async () => [
+      ...calendarsDb,
+    ]);
+    calendarQueries.getEnabledCalendars.mockImplementation(async () =>
+      calendarsDb.filter((c) => c.enabled),
+    );
+    calendarQueries.insertCalendar.mockImplementation(
+      async (cal: CalRecord) => {
+        calendarsDb.push({
+          ...cal,
+          createdAt: cal.createdAt ?? new Date().toISOString(),
+        });
+      },
+    );
+    calendarQueries.updateCalendar.mockImplementation(
+      async (id: string, fields: Partial<CalRecord>) => {
+        const idx = calendarsDb.findIndex((c) => c.id === id);
+        if (idx >= 0) {
+          calendarsDb[idx] = { ...calendarsDb[idx], ...fields };
+        }
+      },
+    );
+    calendarQueries.deleteCalendar.mockImplementation(async (id: string) => {
+      calendarsDb = calendarsDb.filter((c) => c.id !== id);
+    });
+    calendarQueries.deleteEventsByCalendarId.mockResolvedValue(undefined);
   });
 
   test("keeps Google calendars isolated per connection when ids overlap", async () => {
-    const store = createStore();
-
-    store.setRow("calendars", "john-row", {
-      user_id: "user-1",
-      created_at: "2026-03-25T00:00:00.000Z",
-      tracking_id_calendar: "primary",
+    calendarsDb.push({
+      id: "john-row",
+      trackingIdCalendar: "primary",
       name: "John (Char)",
       enabled: true,
       provider: "google",
       source: "john@char.com",
       color: "#4285f4",
-      connection_id: "conn-john",
+      connectionId: "conn-john",
+      createdAt: "2026-03-25T00:00:00.000Z",
     });
 
     pluginCalendar.listCalendars.mockImplementation(
@@ -89,28 +139,28 @@ describe("syncCalendars", () => {
       },
     );
 
-    await syncCalendars(store, [
+    await syncCalendars([
       {
         provider: "google",
         connection_ids: ["conn-john", "conn-gmail"],
       },
     ]);
 
-    const calendars = getCalendarsByConnection(store, "google");
+    const googleCalendars = calendarsDb.filter((c) => c.provider === "google");
 
-    expect(calendars).toHaveLength(2);
+    expect(googleCalendars).toHaveLength(2);
     expect(
-      calendars.find((calendar) => calendar.connection_id === "conn-john"),
+      googleCalendars.find((c) => c.connectionId === "conn-john"),
     ).toMatchObject({
-      tracking_id_calendar: "primary",
+      trackingIdCalendar: "primary",
       name: "John (Char)",
       enabled: true,
       source: "john@char.com",
     });
     expect(
-      calendars.find((calendar) => calendar.connection_id === "conn-gmail"),
+      googleCalendars.find((c) => c.connectionId === "conn-gmail"),
     ).toMatchObject({
-      tracking_id_calendar: "primary",
+      trackingIdCalendar: "primary",
       name: "Personal",
       enabled: false,
       source: "jeeheontransformers@gmail.com",
@@ -118,30 +168,30 @@ describe("syncCalendars", () => {
   });
 
   test("removes calendars for disconnected accounts even when ids overlap", async () => {
-    const store = createStore();
-
-    store.setRow("calendars", "john-row", {
-      user_id: "user-1",
-      created_at: "2026-03-25T00:00:00.000Z",
-      tracking_id_calendar: "primary",
-      name: "John (Char)",
-      enabled: true,
-      provider: "google",
-      source: "john@char.com",
-      color: "#4285f4",
-      connection_id: "conn-john",
-    });
-    store.setRow("calendars", "gmail-row", {
-      user_id: "user-1",
-      created_at: "2026-03-25T00:00:00.000Z",
-      tracking_id_calendar: "primary",
-      name: "Personal",
-      enabled: false,
-      provider: "google",
-      source: "jeeheontransformers@gmail.com",
-      color: "#a142f4",
-      connection_id: "conn-gmail",
-    });
+    calendarsDb.push(
+      {
+        id: "john-row",
+        trackingIdCalendar: "primary",
+        name: "John (Char)",
+        enabled: true,
+        provider: "google",
+        source: "john@char.com",
+        color: "#4285f4",
+        connectionId: "conn-john",
+        createdAt: "2026-03-25T00:00:00.000Z",
+      },
+      {
+        id: "gmail-row",
+        trackingIdCalendar: "primary",
+        name: "Personal",
+        enabled: false,
+        provider: "google",
+        source: "jeeheontransformers@gmail.com",
+        color: "#a142f4",
+        connectionId: "conn-gmail",
+        createdAt: "2026-03-25T00:00:00.000Z",
+      },
+    );
 
     pluginCalendar.listCalendars.mockResolvedValue({
       status: "success",
@@ -155,18 +205,18 @@ describe("syncCalendars", () => {
       ],
     });
 
-    await syncCalendars(store, [
+    await syncCalendars([
       {
         provider: "google",
         connection_ids: ["conn-gmail"],
       },
     ]);
 
-    const calendars = getCalendarsByConnection(store, "google");
+    const googleCalendars = calendarsDb.filter((c) => c.provider === "google");
 
-    expect(calendars).toHaveLength(1);
-    expect(calendars[0]).toMatchObject({
-      connection_id: "conn-gmail",
+    expect(googleCalendars).toHaveLength(1);
+    expect(googleCalendars[0]).toMatchObject({
+      connectionId: "conn-gmail",
       name: "Personal",
     });
   });
diff --git a/apps/desktop/src/services/calendar/ctx.ts b/apps/desktop/src/services/calendar/ctx.ts
index 1421b035ea..9899a896e8 100644
--- a/apps/desktop/src/services/calendar/ctx.ts
+++ b/apps/desktop/src/services/calendar/ctx.ts
@@ -1,5 +1,3 @@
-import type { Queries } from "tinybase/with-schemas";
-
 import { commands as calendarCommands } from "@hypr/plugin-calendar";
 import type {
   CalendarListItem,
@@ -7,11 +5,19 @@ import type {
   ProviderConnectionIds,
 } from "@hypr/plugin-calendar";
 
+import {
+  deleteCalendar,
+  deleteEventsByCalendarId,
+  getAllCalendars,
+  getEnabledCalendars,
+  insertCalendar,
+  updateCalendar,
+} from "~/calendar/queries";
 import {
   findCalendarByTrackingId,
   getCalendarTrackingKey,
 } from "~/calendar/utils";
-import { QUERIES, type Schemas, type Store } from "~/store/tinybase/store/main";
+import type { Store } from "~/store/tinybase/store/main";
 
 // ---
 
@@ -28,52 +34,39 @@ export interface Ctx {
 
 // ---
 
-export function createCtx(
+export async function createCtx(
   store: Store,
-  queries: Queries<Schemas>,
+  userId: string,
   provider: CalendarProviderType,
   connectionId: string,
-): Ctx | null {
-  const resultTable = queries.getResultTable(QUERIES.enabledCalendars);
+): Promise<Ctx | null> {
+  const enabledCalendars = await getEnabledCalendars();
 
   const calendarIds = new Set<string>();
   const calendarTrackingIdToId = new Map<string, string>();
 
-  for (const calendarId of Object.keys(resultTable)) {
-    const calendar = store.getRow("calendars", calendarId);
+  for (const calendar of enabledCalendars) {
     if (
-      calendar?.provider !== provider ||
-      calendar?.connection_id !== connectionId
+      calendar.provider !== provider ||
+      calendar.connectionId !== connectionId
     ) {
       continue;
     }
 
-    calendarIds.add(calendarId);
+    calendarIds.add(calendar.id);
 
-    const trackingId = calendar?.tracking_id_calendar as string | undefined;
-    if (trackingId) {
-      calendarTrackingIdToId.set(trackingId, calendarId);
+    if (calendar.trackingIdCalendar) {
+      calendarTrackingIdToId.set(calendar.trackingIdCalendar, calendar.id);
     }
   }
 
-  // We can't do this because we need a ctx to delete
-  // left-over events from old calendars in sync
-  // if (calendarTrackingIdToId.size === 0) {
-  //   return null;
-  // }
-
-  const userId = store.getValue("user_id");
-  if (!userId) {
-    return null;
-  }
-
   const { from, to } = getRange();
 
   return {
     store,
     provider,
     connectionId,
-    userId: String(userId),
+    userId,
     from,
     to,
     calendarIds,
@@ -92,12 +85,8 @@ export async function getProviderConnections(): Promise<
 }
 
 export async function syncCalendars(
-  store: Store,
   providerConnections: ProviderConnectionIds[],
 ): Promise<void> {
-  const userId = store.getValue("user_id");
-  if (!userId) return;
-
   for (const { provider, connection_ids } of providerConnections) {
     const perConnection: {
       connectionId: string;
@@ -130,65 +119,64 @@ export async function syncCalendars(
       ),
     );
 
-    store.transaction(() => {
-      const disabledCalendarIds = new Set<string>();
-
-      for (const rowId of store.getRowIds("calendars")) {
-        const row = store.getRow("calendars", rowId);
-        if (
-          row.provider === provider &&
-          (!requestedConnectionIds.has(row.connection_id as string) ||
-            (successfulConnectionIds.has(row.connection_id as string) &&
-              !incomingKeys.has(
-                getCalendarTrackingKey({
-                  provider: row.provider as string | undefined,
-                  connectionId: row.connection_id as string | undefined,
-                  trackingId: row.tracking_id_calendar as string | undefined,
-                }),
-              )))
-        ) {
-          disabledCalendarIds.add(rowId);
-          store.delRow("calendars", rowId);
-        } else if (row.provider === provider && !row.enabled) {
-          disabledCalendarIds.add(rowId);
-        }
+    const allCalendars = await getAllCalendars();
+    const disabledCalendarIds = new Set<string>();
+
+    for (const cal of allCalendars) {
+      if (
+        cal.provider === provider &&
+        (!requestedConnectionIds.has(cal.connectionId) ||
+          (successfulConnectionIds.has(cal.connectionId) &&
+            !incomingKeys.has(
+              getCalendarTrackingKey({
+                provider: cal.provider,
+                connectionId: cal.connectionId,
+                trackingId: cal.trackingIdCalendar,
+              }),
+            )))
+      ) {
+        disabledCalendarIds.add(cal.id);
+        await deleteCalendar(cal.id);
+      } else if (cal.provider === provider && !cal.enabled) {
+        disabledCalendarIds.add(cal.id);
       }
+    }
 
-      if (disabledCalendarIds.size > 0) {
-        for (const eventId of store.getRowIds("events")) {
-          const event = store.getRow("events", eventId);
-          if (event.calendar_id && disabledCalendarIds.has(event.calendar_id)) {
-            store.delRow("events", eventId);
-          }
-        }
-      }
+    for (const calId of disabledCalendarIds) {
+      await deleteEventsByCalendarId(calId);
+    }
 
-      for (const { connectionId, calendars } of perConnection) {
-        for (const cal of calendars) {
-          const existingRowId = findCalendarByTrackingId(store, {
+    for (const { connectionId, calendars } of perConnection) {
+      for (const cal of calendars) {
+        const existingRowId = await findCalendarByTrackingId({
+          provider,
+          connectionId,
+          trackingId: cal.id,
+        });
+
+        if (existingRowId) {
+          await updateCalendar(existingRowId, {
+            trackingIdCalendar: cal.id,
+            name: cal.title,
             provider,
+            source: cal.source ?? "",
+            color: cal.color ?? "#888",
             connectionId,
-            trackingId: cal.id,
           });
-          const rowId = existingRowId ?? crypto.randomUUID();
-          const existing = existingRowId
-            ? store.getRow("calendars", existingRowId)
-            : null;
-
-          store.setRow("calendars", rowId, {
-            user_id: String(userId),
-            created_at: existing?.created_at || new Date().toISOString(),
-            tracking_id_calendar: cal.id,
+        } else {
+          await insertCalendar({
+            id: crypto.randomUUID(),
+            trackingIdCalendar: cal.id,
             name: cal.title,
-            enabled: existing?.enabled ?? false,
+            enabled: false,
             provider,
-            source: cal.source ?? undefined,
+            source: cal.source ?? "",
             color: cal.color ?? "#888",
-            connection_id: connectionId,
+            connectionId,
           });
         }
       }
-    });
+    }
   }
 }
 
diff --git a/apps/desktop/src/services/calendar/fetch/existing.ts b/apps/desktop/src/services/calendar/fetch/existing.ts
index 6d22346022..d7d93ff385 100644
--- a/apps/desktop/src/services/calendar/fetch/existing.ts
+++ b/apps/desktop/src/services/calendar/fetch/existing.ts
@@ -1,58 +1,33 @@
 import type { Ctx } from "../ctx";
 import type { ExistingEvent } from "./types";
 
-function isEventInRange(
-  startedAt: string,
-  endedAt: string | undefined,
-  from: Date,
-  to: Date,
-): boolean {
-  const eventStart = new Date(startedAt);
-  const eventEnd = endedAt ? new Date(endedAt) : eventStart;
-
-  return eventStart <= to && eventEnd >= from;
-}
-
-export function fetchExistingEvents(ctx: Ctx): ExistingEvent[] {
-  const events: ExistingEvent[] = [];
-
-  ctx.store.forEachRow("events", (rowId, _forEachCell) => {
-    const event = ctx.store.getRow("events", rowId);
-    if (!event) return;
-
-    const calendarId = event.calendar_id;
-    if (!calendarId) {
-      return;
-    }
-
-    if (!ctx.calendarIds.has(calendarId)) {
-      return;
-    }
-
-    const startedAt = event.started_at;
-    if (!startedAt) return;
-
-    const endedAt = event.ended_at;
-    if (isEventInRange(startedAt, endedAt, ctx.from, ctx.to)) {
-      events.push({
-        id: rowId,
-        tracking_id_event: event.tracking_id_event,
-        user_id: event.user_id,
-        created_at: event.created_at,
-        calendar_id: calendarId,
-        title: event.title,
-        started_at: startedAt,
-        ended_at: endedAt,
-        location: event.location,
-        meeting_link: event.meeting_link,
-        description: event.description,
-        note: event.note,
-        recurrence_series_id: event.recurrence_series_id,
-        has_recurrence_rules: event.has_recurrence_rules,
-        provider: event.provider,
-      });
-    }
-  });
-
-  return events;
+import { getEventsByCalendarIds } from "~/calendar/queries";
+
+export async function fetchExistingEvents(ctx: Ctx): Promise<ExistingEvent[]> {
+  const calendarIds = Array.from(ctx.calendarIds);
+  if (calendarIds.length === 0) return [];
+
+  const records = await getEventsByCalendarIds(
+    calendarIds,
+    ctx.from.toISOString(),
+    ctx.to.toISOString(),
+  );
+
+  return records.map((r) => ({
+    id: r.id,
+    tracking_id_event: r.trackingIdEvent,
+    calendar_id: r.calendarId,
+    title: r.title,
+    started_at: r.startedAt,
+    ended_at: r.endedAt,
+    location: r.location,
+    meeting_link: r.meetingLink,
+    description: r.description,
+    note: r.note,
+    recurrence_series_id: r.recurrenceSeriesId,
+    has_recurrence_rules: r.hasRecurrenceRules,
+    provider: r.provider,
+    user_id: ctx.userId,
+    created_at: r.createdAt,
+  }));
 }
diff --git a/apps/desktop/src/services/calendar/index.ts b/apps/desktop/src/services/calendar/index.ts
index b9df71f8aa..d420e59a66 100644
--- a/apps/desktop/src/services/calendar/index.ts
+++ b/apps/desktop/src/services/calendar/index.ts
@@ -22,21 +22,25 @@ export const CALENDAR_SYNC_TASK_ID = "calendarSync";
 
 export async function syncCalendarEvents(
   store: Store,
-  queries: Queries<Schemas>,
+  _queries?: Queries<Schemas>,
 ): Promise<void> {
   await Promise.all([
     new Promise((resolve) => setTimeout(resolve, 250)),
-    run(store, queries),
+    run(store),
   ]);
 }
 
-async function run(store: Store, queries: Queries<Schemas>) {
+async function run(store: Store) {
   const providerConnections = await getProviderConnections();
-  await syncCalendars(store, providerConnections);
+  await syncCalendars(providerConnections);
+
+  const userId = store.getValue("user_id");
+  if (!userId) return;
+
   for (const { provider, connection_ids } of providerConnections) {
     for (const connectionId of connection_ids) {
       try {
-        await runForConnection(store, queries, provider, connectionId);
+        await runForConnection(store, String(userId), provider, connectionId);
       } catch (error) {
         console.error(
           `[calendar-sync] Error syncing ${provider} (${connectionId}): ${error}`,
@@ -48,11 +52,11 @@ async function run(store: Store, queries: Queries<Schemas>) {
 
 async function runForConnection(
   store: Store,
-  queries: Queries<Schemas>,
+  userId: string,
   provider: CalendarProviderType,
   connectionId: string,
 ) {
-  const ctx = createCtx(store, queries, provider, connectionId);
+  const ctx = await createCtx(store, userId, provider, connectionId);
   if (!ctx) {
     return;
   }
@@ -74,14 +78,14 @@ async function runForConnection(
     throw error;
   }
 
-  const existing = fetchExistingEvents(ctx);
+  const existing = await fetchExistingEvents(ctx);
 
   const eventsOut = syncEvents(ctx, {
     incoming,
     existing,
     incomingParticipants,
   });
-  executeForEventsSync(ctx, eventsOut);
+  await executeForEventsSync(ctx, eventsOut);
   syncSessionEmbeddedEvents(ctx, incoming);
 
   const participantsOut = syncSessionParticipants(ctx, {
diff --git a/apps/desktop/src/services/calendar/process/events/execute.ts b/apps/desktop/src/services/calendar/process/events/execute.ts
index ac199fb9ef..9f5f6c359d 100644
--- a/apps/desktop/src/services/calendar/process/events/execute.ts
+++ b/apps/desktop/src/services/calendar/process/events/execute.ts
@@ -1,78 +1,78 @@
-import type { EventStorage, SessionEvent } from "@hypr/store";
+import type { SessionEvent } from "@hypr/store";
 
 import type { Ctx } from "../../ctx";
 import type { IncomingEvent } from "../../fetch/types";
 import type { EventsSyncOutput } from "./types";
 
+import { deleteEvent, insertEvent, updateEvent } from "~/calendar/queries";
 import { getSessionEventById } from "~/session/utils";
 import { id } from "~/shared/utils";
 
-export function executeForEventsSync(ctx: Ctx, out: EventsSyncOutput): void {
-  const userId = ctx.store.getValue("user_id");
+export async function executeForEventsSync(
+  ctx: Ctx,
+  out: EventsSyncOutput,
+): Promise<void> {
+  const userId = ctx.userId;
   if (!userId) {
     throw new Error("user_id is not set");
   }
 
   const now = new Date().toISOString();
 
-  ctx.store.transaction(() => {
-    for (const eventId of out.toDelete) {
-      ctx.store.delRow("events", eventId);
-    }
-
-    for (const event of out.toUpdate) {
-      ctx.store.setPartialRow("events", event.id, {
-        tracking_id_event: event.tracking_id_event,
-        calendar_id: event.calendar_id,
-        title: event.title,
-        started_at: event.started_at,
-        ended_at: event.ended_at,
-        location: event.location,
-        meeting_link: event.meeting_link,
-        description: event.description,
-        recurrence_series_id: event.recurrence_series_id,
-        has_recurrence_rules: event.has_recurrence_rules,
-        is_all_day: event.is_all_day,
-        provider: ctx.provider,
-        participants_json:
-          event.participants.length > 0
-            ? JSON.stringify(event.participants)
-            : undefined,
-      });
-    }
-
-    for (const eventToAdd of out.toAdd) {
-      const calendarId = ctx.calendarTrackingIdToId.get(
-        eventToAdd.tracking_id_calendar,
-      );
-      if (!calendarId) {
-        continue;
-      }
+  for (const eventId of out.toDelete) {
+    await deleteEvent(eventId);
+  }
 
-      const eventId = id();
+  for (const event of out.toUpdate) {
+    await updateEvent(event.id, {
+      trackingIdEvent: event.tracking_id_event,
+      calendarId: event.calendar_id,
+      title: event.title,
+      startedAt: event.started_at,
+      endedAt: event.ended_at,
+      location: event.location,
+      meetingLink: event.meeting_link,
+      description: event.description,
+      recurrenceSeriesId: event.recurrence_series_id,
+      hasRecurrenceRules: event.has_recurrence_rules,
+      isAllDay: event.is_all_day,
+      provider: ctx.provider,
+      participantsJson:
+        event.participants.length > 0
+          ? JSON.stringify(event.participants)
+          : undefined,
+    });
+  }
 
-      ctx.store.setRow("events", eventId, {
-        user_id: userId,
-        created_at: now,
-        tracking_id_event: eventToAdd.tracking_id_event,
-        calendar_id: calendarId,
-        title: eventToAdd.title ?? "",
-        started_at: eventToAdd.started_at ?? "",
-        ended_at: eventToAdd.ended_at ?? "",
-        location: eventToAdd.location,
-        meeting_link: eventToAdd.meeting_link,
-        description: eventToAdd.description,
-        recurrence_series_id: eventToAdd.recurrence_series_id,
-        has_recurrence_rules: eventToAdd.has_recurrence_rules,
-        is_all_day: eventToAdd.is_all_day,
-        provider: ctx.provider,
-        participants_json:
-          eventToAdd.participants.length > 0
-            ? JSON.stringify(eventToAdd.participants)
-            : undefined,
-      } satisfies EventStorage);
+  for (const eventToAdd of out.toAdd) {
+    const calendarId = ctx.calendarTrackingIdToId.get(
+      eventToAdd.tracking_id_calendar,
+    );
+    if (!calendarId) {
+      continue;
     }
-  });
+
+    await insertEvent({
+      id: id(),
+      trackingIdEvent: eventToAdd.tracking_id_event,
+      calendarId,
+      title: eventToAdd.title ?? "",
+      startedAt: eventToAdd.started_at ?? "",
+      endedAt: eventToAdd.ended_at ?? "",
+      location: eventToAdd.location ?? "",
+      meetingLink: eventToAdd.meeting_link ?? "",
+      description: eventToAdd.description ?? "",
+      recurrenceSeriesId: eventToAdd.recurrence_series_id ?? "",
+      hasRecurrenceRules: eventToAdd.has_recurrence_rules,
+      isAllDay: eventToAdd.is_all_day,
+      provider: ctx.provider,
+      participantsJson:
+        eventToAdd.participants.length > 0
+          ? JSON.stringify(eventToAdd.participants)
+          : undefined,
+      createdAt: now,
+    });
+  }
 }
 
 export function syncSessionEmbeddedEvents(
diff --git a/apps/desktop/src/services/event-listeners.test.tsx b/apps/desktop/src/services/event-listeners.test.tsx
index 305de53a95..e8bb172db9 100644
--- a/apps/desktop/src/services/event-listeners.test.tsx
+++ b/apps/desktop/src/services/event-listeners.test.tsx
@@ -22,7 +22,9 @@ const {
   useSettingsStoreMock: vi.fn(() => null),
   openNewMock: vi.fn(),
   createSessionMock: vi.fn(() => "session-new"),
-  getOrCreateSessionForEventIdMock: vi.fn(() => "session-event"),
+  getOrCreateSessionForEventIdMock: vi.fn(() =>
+    Promise.resolve("session-event"),
+  ),
 }));
 
 vi.mock("@hypr/plugin-notification", () => ({
@@ -88,7 +90,9 @@ describe("EventListeners notification events", () => {
     notificationListenMock.mockResolvedValue(() => {});
     updaterListenMock.mockResolvedValue(() => {});
     createSessionMock.mockReturnValue("session-new");
-    getOrCreateSessionForEventIdMock.mockReturnValue("session-event");
+    getOrCreateSessionForEventIdMock.mockReturnValue(
+      Promise.resolve("session-event"),
+    );
     useMainStoreMock.mockReturnValue(null);
     useSettingsStoreMock.mockReturnValue(null);
   });
diff --git a/apps/desktop/src/services/event-listeners.tsx b/apps/desktop/src/services/event-listeners.tsx
index c7fbab90c4..948fd2b732 100644
--- a/apps/desktop/src/services/event-listeners.tsx
+++ b/apps/desktop/src/services/event-listeners.tsx
@@ -80,14 +80,16 @@ function useNotificationEvents() {
     if (pendingAutoStart.current && store) {
       const { eventId } = pendingAutoStart.current;
       pendingAutoStart.current = null;
-      const sessionId = eventId
-        ? getOrCreateSessionForEventId(store, eventId)
-        : createSession(store);
-      openNew({
-        type: "sessions",
-        id: sessionId,
-        state: { view: null, autoStart: true },
-      });
+      void (async () => {
+        const sessionId = eventId
+          ? await getOrCreateSessionForEventId(store, eventId)
+          : createSession(store);
+        openNew({
+          type: "sessions",
+          id: sessionId,
+          state: { view: null, autoStart: true },
+        });
+      })();
     }
   }, [store, openNew]);
 
@@ -114,14 +116,16 @@ function useNotificationEvents() {
             pendingAutoStart.current = { eventId };
             return;
           }
-          const sessionId = eventId
-            ? getOrCreateSessionForEventId(currentStore, eventId)
-            : createSession(currentStore);
-          openNewRef.current({
-            type: "sessions",
-            id: sessionId,
-            state: { view: null, autoStart: true },
-          });
+          void (async () => {
+            const sessionId = eventId
+              ? await getOrCreateSessionForEventId(currentStore, eventId)
+              : createSession(currentStore);
+            openNewRef.current({
+              type: "sessions",
+              id: sessionId,
+              state: { view: null, autoStart: true },
+            });
+          })();
         } else if (payload.type === "notification_option_selected") {
           const currentStore = storeRef.current;
           if (!currentStore) return;
@@ -132,19 +136,21 @@ function useNotificationEvents() {
               ? (payload.source.event_ids ?? [])
               : [];
 
-          const sessionId =
-            selectedIndex < eventIds.length
-              ? getOrCreateSessionForEventId(
-                  currentStore,
-                  eventIds[selectedIndex],
-                )
-              : createSession(currentStore);
-
-          openNewRef.current({
-            type: "sessions",
-            id: sessionId,
-            state: { view: null, autoStart: true },
-          });
+          void (async () => {
+            const sessionId =
+              selectedIndex < eventIds.length
+                ? await getOrCreateSessionForEventId(
+                    currentStore,
+                    eventIds[selectedIndex],
+                  )
+                : createSession(currentStore);
+
+            openNewRef.current({
+              type: "sessions",
+              id: sessionId,
+              state: { view: null, autoStart: true },
+            });
+          })();
         } else if (payload.type === "notification_footer_action") {
           if (payload.source?.type !== "mic_detected") {
             return;
diff --git a/apps/desktop/src/services/event-notification/index.ts b/apps/desktop/src/services/event-notification/index.ts
index 959598785b..d737168836 100644
--- a/apps/desktop/src/services/event-notification/index.ts
+++ b/apps/desktop/src/services/event-notification/index.ts
@@ -4,6 +4,7 @@ import {
   type Participant,
 } from "@hypr/plugin-notification";
 
+import { getAllEvents } from "~/calendar/queries";
 import { findSessionByEventId } from "~/session/utils";
 import type * as main from "~/store/tinybase/store/main";
 import type * as settings from "~/store/tinybase/store/settings";
@@ -42,7 +43,7 @@ function getParticipantsForSession(
   return participants;
 }
 
-export function checkEventNotifications(
+export async function checkEventNotifications(
   store: main.Store,
   settingsStore: settings.Store,
   notifiedEvents: NotifiedEventsMap,
@@ -85,42 +86,42 @@ export function checkEventNotifications(
     }
   } catch {}
 
-  store.forEachRow("events", (eventId, _forEachCell) => {
-    const event = store.getRow("events", eventId);
-    if (!event?.started_at) return;
+  const allEvents = await getAllEvents();
 
-    const startTime = new Date(String(event.started_at));
+  for (const event of allEvents) {
+    if (!event.startedAt) continue;
+
+    const startTime = new Date(event.startedAt);
     const timeUntilStart = startTime.getTime() - now;
-    const notificationKey = `event-${eventId}-${startTime.getTime()}`;
+    const notificationKey = `event-${event.id}-${startTime.getTime()}`;
 
-    const trackingId = event.tracking_id_event as string | undefined;
-    const recurrenceSeriesId = event.recurrence_series_id as string | undefined;
+    const trackingId = event.trackingIdEvent;
+    const recurrenceSeriesId = event.recurrenceSeriesId;
 
     if (trackingId) {
-      if (ignoredIds.has(trackingId)) return;
+      if (ignoredIds.has(trackingId)) continue;
       if (recurrenceSeriesId && ignoredSeriesIds.has(recurrenceSeriesId))
-        return;
+        continue;
     }
 
     if (timeUntilStart > 0 && timeUntilStart <= NOTIFY_WINDOW_MS) {
       if (notifiedEvents.has(notificationKey)) {
-        return;
+        continue;
       }
 
       notifiedEvents.set(notificationKey, now);
 
-      const title = String(event.title || "Upcoming Event");
+      const title = event.title || "Upcoming Event";
       const minutesUntil = Math.ceil(timeUntilStart / 60000);
 
       const eventDetails: EventDetails = {
         what: title,
         timezone: null,
-        location:
-          (event.meeting_link as string) || (event.location as string) || null,
+        location: event.meetingLink || event.location || null,
       };
 
       let participants: Participant[] | null = null;
-      const sessionId = findSessionByEventId(store, eventId);
+      const sessionId = await findSessionByEventId(store, event.id);
       if (sessionId) {
         const sessionParticipants = getParticipantsForSession(store, sessionId);
         if (sessionParticipants.length > 0) {
@@ -133,7 +134,7 @@ export function checkEventNotifications(
         title: title,
         message: `Starting in ${minutesUntil} minute${minutesUntil !== 1 ? "s" : ""}`,
         timeout: null,
-        source: { type: "calendar_event", event_id: eventId },
+        source: { type: "calendar_event", event_id: event.id },
         start_time: Math.floor(startTime.getTime() / 1000),
         participants: participants,
         event_details: eventDetails,
@@ -145,5 +146,5 @@ export function checkEventNotifications(
     } else if (timeUntilStart <= 0) {
       notifiedEvents.delete(notificationKey);
     }
-  });
+  }
 }
diff --git a/apps/desktop/src/services/task-manager.tsx b/apps/desktop/src/services/task-manager.tsx
index f983d00837..e97f60c8f7 100644
--- a/apps/desktop/src/services/task-manager.tsx
+++ b/apps/desktop/src/services/task-manager.tsx
@@ -57,7 +57,7 @@ export function TaskManager() {
 
   useSetTask(EVENT_NOTIFICATION_TASK_ID, async () => {
     if (!store || !settingsStore) return;
-    checkEventNotifications(
+    await checkEventNotifications(
       store as main.Store,
       settingsStore as settings.Store,
       notifiedEventsRef.current,
diff --git a/apps/desktop/src/session/utils.ts b/apps/desktop/src/session/utils.ts
index dfc27be99c..3f13b7bac0 100644
--- a/apps/desktop/src/session/utils.ts
+++ b/apps/desktop/src/session/utils.ts
@@ -1,5 +1,6 @@
 import type { SessionEvent } from "@hypr/store";
 
+import { eventExists, getEventById } from "~/calendar/queries";
 import type * as main from "~/store/tinybase/store/main";
 
 type Store = NonNullable<ReturnType<typeof main.UI.useStore>>;
@@ -41,14 +42,14 @@ export function findSessionByTrackingId(
   return found;
 }
 
-export function findSessionByEventId(
+export async function findSessionByEventId(
   store: Store,
   eventId: string,
-): string | null {
-  if (!store.hasRow("events", eventId)) return null;
-  const event = store.getRow("events", eventId);
+): Promise<string | null> {
+  if (!(await eventExists(eventId))) return null;
+  const event = await getEventById(eventId);
   if (!event) return null;
-  const trackingId = event.tracking_id_event;
+  const trackingId = event.trackingIdEvent;
   if (!trackingId) return null;
   return findSessionByTrackingId(store, trackingId);
 }
diff --git a/apps/desktop/src/sidebar/timeline/index.tsx b/apps/desktop/src/sidebar/timeline/index.tsx
index e03fdf8aa3..fd6f083eff 100644
--- a/apps/desktop/src/sidebar/timeline/index.tsx
+++ b/apps/desktop/src/sidebar/timeline/index.tsx
@@ -32,6 +32,7 @@ import {
   type TimelineSessionsTable,
 } from "./utils";
 
+import { useTimelineEvents } from "~/calendar/queries";
 import { useConfigValue } from "~/shared/config";
 import { useNativeContextMenu } from "~/shared/hooks/useNativeContextMenu";
 import { useIgnoredEvents } from "~/store/tinybase/hooks";
@@ -549,10 +550,7 @@ function useTimelineTables(): {
   timelineEventsTable: TimelineEventsTable;
   timelineSessionsTable: TimelineSessionsTable;
 } {
-  const timelineEventsTable = main.UI.useResultTable(
-    main.QUERIES.timelineEvents,
-    main.STORE_ID,
-  );
+  const timelineEventsTable = useTimelineEvents();
   const timelineSessionsTable = main.UI.useResultTable(
     main.QUERIES.timelineSessions,
     main.STORE_ID,
diff --git a/apps/desktop/src/sidebar/timeline/item.tsx b/apps/desktop/src/sidebar/timeline/item.tsx
index cc67ee635c..302204291f 100644
--- a/apps/desktop/src/sidebar/timeline/item.tsx
+++ b/apps/desktop/src/sidebar/timeline/item.tsx
@@ -18,6 +18,7 @@ import {
   TimelinePrecision,
 } from "./utils";
 
+import { useCalendarById } from "~/calendar/queries";
 import { SessionPreviewCard } from "~/session/components/session-preview-card";
 import { useIsSessionEnhancing } from "~/session/hooks/useEnhancedNotes";
 import { getSessionEvent } from "~/session/utils";
@@ -196,9 +197,12 @@ const EventItem = memo(
           return;
         }
 
-        const sessionId = getOrCreateSessionForEventId(store, eventId, title);
-        const tab: TabInput = { id: sessionId, type: "sessions" };
-        openInNewTab ? openNew(tab) : openCurrent(tab);
+        void getOrCreateSessionForEventId(store, eventId, title).then(
+          (sessionId) => {
+            const tab: TabInput = { id: sessionId, type: "sessions" };
+            openInNewTab ? openNew(tab) : openCurrent(tab);
+          },
+        );
       },
       [eventId, store, title, openCurrent, openNew],
     );
@@ -498,10 +502,10 @@ function formatDisplayTime(
 }
 
 function CalendarIndicator({ calendarId }: { calendarId: string }) {
-  const calendar = main.UI.useRow("calendars", calendarId, main.STORE_ID);
+  const calendar = useCalendarById(calendarId);
 
-  const name = calendar?.name ? String(calendar.name) : undefined;
-  const color = calendar?.color ? String(calendar.color) : "#888";
+  const name = calendar?.name ?? undefined;
+  const color = calendar?.color ?? "#888";
 
   return (
     <Tooltip delayDuration={0}>
diff --git a/apps/desktop/src/store/tinybase/hooks/index.tsx b/apps/desktop/src/store/tinybase/hooks/index.tsx
index 04a9429158..e50ce0f028 100644
--- a/apps/desktop/src/store/tinybase/hooks/index.tsx
+++ b/apps/desktop/src/store/tinybase/hooks/index.tsx
@@ -109,76 +109,6 @@ export function useOrganization(orgId: string) {
   return useMemo(() => ({ name }), [name]);
 }
 
-export function useEvent(eventId: string | undefined) {
-  const title = main.UI.useCell(
-    "events",
-    eventId ?? "",
-    "title",
-    main.STORE_ID,
-  );
-  const startedAt = main.UI.useCell(
-    "events",
-    eventId ?? "",
-    "started_at",
-    main.STORE_ID,
-  );
-  const endedAt = main.UI.useCell(
-    "events",
-    eventId ?? "",
-    "ended_at",
-    main.STORE_ID,
-  );
-  const location = main.UI.useCell(
-    "events",
-    eventId ?? "",
-    "location",
-    main.STORE_ID,
-  );
-  const meetingLink = main.UI.useCell(
-    "events",
-    eventId ?? "",
-    "meeting_link",
-    main.STORE_ID,
-  );
-  const description = main.UI.useCell(
-    "events",
-    eventId ?? "",
-    "description",
-    main.STORE_ID,
-  );
-  const calendarId = main.UI.useCell(
-    "events",
-    eventId ?? "",
-    "calendar_id",
-    main.STORE_ID,
-  );
-
-  return useMemo(
-    () =>
-      eventId
-        ? {
-            title,
-            startedAt,
-            endedAt,
-            location,
-            meetingLink,
-            description,
-            calendarId,
-          }
-        : null,
-    [
-      eventId,
-      title,
-      startedAt,
-      endedAt,
-      location,
-      meetingLink,
-      description,
-      calendarId,
-    ],
-  );
-}
-
 function parseIgnoredEvents(raw: string | undefined): IgnoredEvent[] {
   if (!raw) return [];
   try {
diff --git a/apps/desktop/src/store/tinybase/persister/calendar/index.ts b/apps/desktop/src/store/tinybase/persister/calendar/index.ts
deleted file mode 100644
index b101bf0170..0000000000
--- a/apps/desktop/src/store/tinybase/persister/calendar/index.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as _UI from "tinybase/ui-react/with-schemas";
-
-import { getCurrentWebviewWindowLabel } from "@hypr/plugin-windows";
-import { type Schemas } from "@hypr/store";
-
-import { createCalendarPersister } from "./persister";
-
-import type { Store } from "~/store/tinybase/store/main";
-
-const { useCreatePersister } = _UI as _UI.WithSchemas<Schemas>;
-
-export function useCalendarPersister(store: Store) {
-  return useCreatePersister(
-    store,
-    async (store) => {
-      const persister = createCalendarPersister(store as Store);
-      if (getCurrentWebviewWindowLabel() === "main") {
-        await persister.startAutoPersisting();
-      } else {
-        await persister.startAutoLoad();
-      }
-      return persister;
-    },
-    [],
-  );
-}
diff --git a/apps/desktop/src/store/tinybase/persister/calendar/persister.ts b/apps/desktop/src/store/tinybase/persister/calendar/persister.ts
deleted file mode 100644
index 0344dc95f8..0000000000
--- a/apps/desktop/src/store/tinybase/persister/calendar/persister.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { createJsonFilePersister } from "~/store/tinybase/persister/factories";
-import type { Store } from "~/store/tinybase/store/main";
-
-export function createCalendarPersister(store: Store) {
-  return createJsonFilePersister(store, {
-    tableName: "calendars",
-    filename: "calendars.json",
-    label: "CalendarPersister",
-  });
-}
diff --git a/apps/desktop/src/store/tinybase/persister/events/index.ts b/apps/desktop/src/store/tinybase/persister/events/index.ts
deleted file mode 100644
index 200d52f211..0000000000
--- a/apps/desktop/src/store/tinybase/persister/events/index.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as _UI from "tinybase/ui-react/with-schemas";
-
-import { getCurrentWebviewWindowLabel } from "@hypr/plugin-windows";
-import { type Schemas } from "@hypr/store";
-
-import { createEventPersister } from "./persister";
-
-import type { Store } from "~/store/tinybase/store/main";
-
-const { useCreatePersister } = _UI as _UI.WithSchemas<Schemas>;
-
-export function useEventsPersister(store: Store) {
-  return useCreatePersister(
-    store,
-    async (store) => {
-      const persister = createEventPersister(store as Store);
-      if (getCurrentWebviewWindowLabel() === "main") {
-        await persister.startAutoPersisting();
-      } else {
-        await persister.startAutoLoad();
-      }
-      return persister;
-    },
-    [],
-  );
-}
diff --git a/apps/desktop/src/store/tinybase/persister/events/persister.ts b/apps/desktop/src/store/tinybase/persister/events/persister.ts
deleted file mode 100644
index a5c33c1b5f..0000000000
--- a/apps/desktop/src/store/tinybase/persister/events/persister.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { createJsonFilePersister } from "~/store/tinybase/persister/factories";
-import type { Store } from "~/store/tinybase/store/main";
-
-export function createEventPersister(store: Store) {
-  return createJsonFilePersister(store, {
-    tableName: "events",
-    filename: "events.json",
-    label: "EventPersister",
-    jsonFields: {
-      participants_json: "participants",
-    },
-  });
-}
diff --git a/apps/desktop/src/store/tinybase/persister/factories/json-file.test.ts b/apps/desktop/src/store/tinybase/persister/factories/json-file.test.ts
index bdd39c8446..0cd37c8c78 100644
--- a/apps/desktop/src/store/tinybase/persister/factories/json-file.test.ts
+++ b/apps/desktop/src/store/tinybase/persister/factories/json-file.test.ts
@@ -43,7 +43,7 @@ describe("createJsonFilePersister", () => {
 
   test("returns a persister object with expected methods", () => {
     const persister = createJsonFilePersister(store, {
-      tableName: "events",
+      tableName: "chat_messages",
       filename: "test.json",
       label: "test",
     });
@@ -60,17 +60,6 @@ describe("createJsonFilePersister", () => {
         "item-1": {
           user_id: "user-1",
           created_at: "2024-01-01T00:00:00Z",
-          tracking_id_event: "tracking-1",
-          calendar_id: "cal-1",
-          title: "Test Event",
-          started_at: "2024-01-01T10:00:00Z",
-          ended_at: "2024-01-01T11:00:00Z",
-          location: "",
-          meeting_link: "",
-          description: "",
-          note: "",
-          is_all_day: false,
-          recurrence_series_id: "",
         },
       };
       fs2Mocks.readTextFile.mockResolvedValue({
@@ -79,7 +68,7 @@ describe("createJsonFilePersister", () => {
       });
 
       const persister = createJsonFilePersister(store, {
-        tableName: "events",
+        tableName: "chat_messages",
         filename: "test.json",
         label: "test",
       });
@@ -88,7 +77,7 @@ describe("createJsonFilePersister", () => {
       expect(fs2Mocks.readTextFile).toHaveBeenCalledWith(
         `${MOCK_DATA_DIR}/test.json`,
       );
-      expect(store.getTable("events")).toEqual(mockData);
+      expect(store.getTable("chat_messages")).toEqual(mockData);
     });
 
     test("handles file not found gracefully", async () => {
@@ -98,36 +87,31 @@ describe("createJsonFilePersister", () => {
       });
 
       const persister = createJsonFilePersister(store, {
-        tableName: "events",
+        tableName: "chat_messages",
         filename: "nonexistent.json",
         label: "test",
       });
       await persister.load();
 
-      expect(store.getTable("events")).toEqual({});
+      expect(store.getTable("chat_messages")).toEqual({});
     });
   });
 
   describe("save", () => {
     test("saves table data to json file", async () => {
-      store.setRow("events", "item-1", {
+      store.setRow("chat_messages", "item-1", {
         user_id: "user-1",
         created_at: "2024-01-01T00:00:00Z",
-        tracking_id_event: "tracking-1",
-        calendar_id: "cal-1",
-        title: "Test Event",
-        started_at: "2024-01-01T10:00:00Z",
-        ended_at: "2024-01-01T11:00:00Z",
-        location: "",
-        meeting_link: "",
-        description: "",
-        note: "",
-        is_all_day: false,
-        recurrence_series_id: "",
+        chat_group_id: "group-1",
+        role: "user",
+        content: "Test message",
+        metadata: "",
+        parts: "",
+        status: "sent",
       });
 
       const persister = createJsonFilePersister(store, {
-        tableName: "events",
+        tableName: "chat_messages",
         filename: "test.json",
         label: "test",
       });
@@ -138,12 +122,12 @@ describe("createJsonFilePersister", () => {
       ]);
 
       const writtenData = fsSyncMocks.writeJsonBatch.mock.calls[0][0][0][0];
-      expect(writtenData["item-1"].title).toBe("Test Event");
+      expect(writtenData["item-1"].content).toBe("Test message");
     });
 
     test("writes empty object when table is empty", async () => {
       const persister = createJsonFilePersister(store, {
-        tableName: "events",
+        tableName: "chat_messages",
         filename: "test.json",
         label: "test",
       });
diff --git a/apps/desktop/src/store/tinybase/store/main.ts b/apps/desktop/src/store/tinybase/store/main.ts
index e51307a970..3238035f52 100644
--- a/apps/desktop/src/store/tinybase/store/main.ts
+++ b/apps/desktop/src/store/tinybase/store/main.ts
@@ -92,16 +92,6 @@ export const StoreComponent = () => {
     store,
     (store) =>
       createQueries(store)
-        .setQueryDefinition(QUERIES.timelineEvents, "events", ({ select }) => {
-          select("title");
-          select("started_at");
-          select("ended_at");
-          select("calendar_id");
-          select("tracking_id_event");
-          select("has_recurrence_rules");
-          select("recurrence_series_id");
-          select("is_all_day");
-        })
         .setQueryDefinition(
           QUERIES.timelineSessions,
           "sessions",
@@ -171,14 +161,6 @@ export const StoreComponent = () => {
             group("ended_at", "max").as("max_ended_at");
           },
         )
-        .setQueryDefinition(
-          QUERIES.enabledCalendars,
-          "calendars",
-          ({ select, where }) => {
-            select("provider");
-            where("enabled", true);
-          },
-        )
         .setQueryDefinition(
           QUERIES.visibleVocabs,
           "memories",
@@ -218,26 +200,6 @@ export const StoreComponent = () => {
         "session_id",
         "created_at",
       )
-      .setIndexDefinition(
-        INDEXES.eventsByDate,
-        "events",
-        (getCell) => {
-          const cell = getCell("started_at");
-          if (!cell) {
-            return "";
-          }
-
-          const d = new Date(cell);
-          if (isNaN(d.getTime())) {
-            return "";
-          }
-
-          return format(d, "yyyy-MM-dd");
-        },
-        "started_at",
-        (a, b) => a.localeCompare(b),
-        (a, b) => String(a).localeCompare(String(b)),
-      )
       .setIndexDefinition(
         INDEXES.sessionByDateWithoutEvent,
         "sessions",
@@ -350,7 +312,6 @@ export const StoreComponent = () => {
 export const rowIdOfChange = (table: string, row: string) => `${table}:${row}`;
 
 export const QUERIES = {
-  timelineEvents: "timelineEvents",
   timelineSessions: "timelineSessions",
   visibleOrganizations: "visibleOrganizations",
   visibleHumans: "visibleHumans",
@@ -358,7 +319,6 @@ export const QUERIES = {
   visibleVocabs: "visibleVocabs",
   sessionParticipantsWithDetails: "sessionParticipantsWithDetails",
   sessionRecordingTimes: "sessionRecordingTimes",
-  enabledCalendars: "enabledCalendars",
 } as const;
 
 export const METRICS = {
@@ -372,7 +332,6 @@ export const INDEXES = {
   sessionParticipantsBySession: "sessionParticipantsBySession",
   sessionsByFolder: "sessionsByFolder",
   transcriptBySession: "transcriptBySession",
-  eventsByDate: "eventsByDate",
   sessionByDateWithoutEvent: "sessionByDateWithoutEvent",
   sessionsByEventTrackingId: "sessionsByEventTrackingId",
   tagSessionsBySession: "tagSessionsBySession",
diff --git a/apps/desktop/src/store/tinybase/store/persisters.ts b/apps/desktop/src/store/tinybase/store/persisters.ts
index e7e19f702c..cbbe385bfc 100644
--- a/apps/desktop/src/store/tinybase/store/persisters.ts
+++ b/apps/desktop/src/store/tinybase/store/persisters.ts
@@ -6,11 +6,9 @@ import { useInitializeStore } from "./initialize";
 import { type Store } from "./main";
 import { registerSaveHandler } from "./save";
 
-import { useCalendarPersister } from "~/store/tinybase/persister/calendar";
 import { useChatPersister } from "~/store/tinybase/persister/chat";
 import { useChatShortcutPersister } from "~/store/tinybase/persister/chat-shortcuts";
 import { useDailyNotePersister } from "~/store/tinybase/persister/daily-note";
-import { useEventsPersister } from "~/store/tinybase/persister/events";
 import { useHumanPersister } from "~/store/tinybase/persister/human";
 import { useMemoryPersister } from "~/store/tinybase/persister/memory";
 import { useOrganizationPersister } from "~/store/tinybase/persister/organization";
@@ -23,10 +21,8 @@ export function useMainPersisters(store: Store) {
   const sessionPersister = useSessionPersister(store);
   const organizationPersister = useOrganizationPersister(store);
   const humanPersister = useHumanPersister(store);
-  const eventPersister = useEventsPersister(store);
   const chatPersister = useChatPersister(store);
   const chatShortcutPersister = useChatShortcutPersister(store);
-  const calendarPersister = useCalendarPersister(store);
   const memoryPersister = useMemoryPersister(store);
   const dailyNotePersister = useDailyNotePersister(store);
   const taskPersister = useTaskPersister(store);
@@ -41,10 +37,8 @@ export function useMainPersisters(store: Store) {
       { id: "session", persister: sessionPersister },
       { id: "organization", persister: organizationPersister },
       { id: "human", persister: humanPersister },
-      { id: "event", persister: eventPersister },
       { id: "chat", persister: chatPersister },
       { id: "chatShortcut", persister: chatShortcutPersister },
-      { id: "calendar", persister: calendarPersister },
       { id: "memory", persister: memoryPersister },
       { id: "dailyNote", persister: dailyNotePersister },
       { id: "task", persister: taskPersister },
@@ -66,10 +60,8 @@ export function useMainPersisters(store: Store) {
     sessionPersister,
     organizationPersister,
     humanPersister,
-    eventPersister,
     chatPersister,
     chatShortcutPersister,
-    calendarPersister,
     memoryPersister,
     dailyNotePersister,
     taskPersister,
@@ -86,10 +78,8 @@ export function useMainPersisters(store: Store) {
     sessionPersister,
     organizationPersister,
     humanPersister,
-    eventPersister,
     chatPersister,
     chatShortcutPersister,
-    calendarPersister,
     memoryPersister,
     dailyNotePersister,
     taskPersister,
diff --git a/apps/desktop/src/store/tinybase/store/sessions.ts b/apps/desktop/src/store/tinybase/store/sessions.ts
index fa79fe9796..725f12d9be 100644
--- a/apps/desktop/src/store/tinybase/store/sessions.ts
+++ b/apps/desktop/src/store/tinybase/store/sessions.ts
@@ -1,6 +1,5 @@
 import { commands as analyticsCommands } from "@hypr/plugin-analytics";
 import type {
-  Event,
   EventParticipant,
   HumanStorage,
   MappingSessionParticipantStorage,
@@ -10,6 +9,7 @@ import { json2md } from "@hypr/tiptap/shared";
 
 import * as main from "./main";
 
+import { eventExists, getEventById } from "~/calendar/queries";
 import { findSessionByEventId } from "~/session/utils";
 import { DEFAULT_USER_ID } from "~/shared/utils";
 import { id } from "~/shared/utils";
@@ -31,38 +31,40 @@ export function createSession(store: Store, title?: string): string {
   return sessionId;
 }
 
-export function getOrCreateSessionForEventId(
+export async function getOrCreateSessionForEventId(
   store: Store,
   eventId: string,
   title?: string,
-): string {
-  if (!store.hasRow("events", eventId)) {
+): Promise<string> {
+  if (!(await eventExists(eventId))) {
     console.trace(
       `[getOrCreateSessionForEventId] event that corresponds to the provided eventId ${eventId} does not exist`,
     );
     return createSession(store, title);
   }
 
-  const existingSessionId = findSessionByEventId(store, eventId);
+  const existingSessionId = await findSessionByEventId(store, eventId);
   if (existingSessionId) {
     return existingSessionId;
   }
 
-  const event = store.getRow("events", eventId) as Event;
+  const event = await getEventById(eventId);
+  if (!event) {
+    return createSession(store, title);
+  }
 
   let sessionEvent: SessionEvent = {
-    tracking_id: event.tracking_id_event,
-    calendar_id: event.calendar_id,
+    tracking_id: event.trackingIdEvent,
+    calendar_id: event.calendarId,
     title: event.title,
-    started_at: event.started_at,
-    ended_at: event.ended_at,
-    // TODO: fix this
-    is_all_day: !!event.is_all_day,
-    has_recurrence_rules: !!event.has_recurrence_rules,
+    started_at: event.startedAt,
+    ended_at: event.endedAt,
+    is_all_day: event.isAllDay,
+    has_recurrence_rules: event.hasRecurrenceRules,
     location: event.location,
-    meeting_link: event.meeting_link,
+    meeting_link: event.meetingLink,
     description: event.description,
-    recurrence_series_id: event.recurrence_series_id,
+    recurrence_series_id: event.recurrenceSeriesId,
   };
 
   const sessionId = id();
@@ -160,13 +162,17 @@ export function isSessionEmpty(store: Store, sessionId: string): boolean {
 function createParticipantsFromEvent(
   store: Store,
   sessionId: string,
-  event: Event,
+  event: { participantsJson: unknown },
 ): void {
-  if (!event.participants_json) return;
+  if (!event.participantsJson) return;
 
   let participants: EventParticipant[];
   try {
-    participants = JSON.parse(event.participants_json);
+    const raw =
+      typeof event.participantsJson === "string"
+        ? event.participantsJson
+        : JSON.stringify(event.participantsJson);
+    participants = JSON.parse(raw);
   } catch {
     return;
   }
diff --git a/apps/desktop/src/stt/contexts.test.tsx b/apps/desktop/src/stt/contexts.test.tsx
index 5395ee3c8a..cae82a4fb3 100644
--- a/apps/desktop/src/stt/contexts.test.tsx
+++ b/apps/desktop/src/stt/contexts.test.tsx
@@ -5,11 +5,14 @@ import { ListenerProvider } from "./contexts";
 
 import { createListenerStore } from "~/store/zustand/listener";
 
-const { listenMock, showNotificationMock, useStoreMock } = vi.hoisted(() => ({
+const mocks = vi.hoisted(() => ({
   listenMock: vi.fn(),
   showNotificationMock: vi.fn(),
   useStoreMock: vi.fn(() => null),
+  getAllEventsMock: vi.fn().mockResolvedValue([]),
 }));
+const { listenMock, showNotificationMock, useStoreMock, getAllEventsMock } =
+  mocks;
 
 vi.mock("@hypr/plugin-detect", () => ({
   events: {
@@ -32,6 +35,10 @@ vi.mock("~/store/tinybase/store/main", () => ({
   },
 }));
 
+vi.mock("~/calendar/queries", () => ({
+  getAllEvents: getAllEventsMock,
+}));
+
 describe("ListenerProvider detect events", () => {
   beforeEach(() => {
     listenMock.mockReset();
@@ -94,6 +101,8 @@ describe("ListenerProvider detect events", () => {
       },
     });
 
+    await vi.waitFor(() => expect(showNotificationMock).toHaveBeenCalled());
+
     expect(showNotificationMock).toHaveBeenCalledWith(
       expect.objectContaining({
         source: {
diff --git a/apps/desktop/src/stt/contexts.tsx b/apps/desktop/src/stt/contexts.tsx
index ad3d084c16..69663efeaf 100644
--- a/apps/desktop/src/stt/contexts.tsx
+++ b/apps/desktop/src/stt/contexts.tsx
@@ -5,7 +5,7 @@ import { useShallow } from "zustand/shallow";
 import { events as detectEvents } from "@hypr/plugin-detect";
 import { commands as notificationCommands } from "@hypr/plugin-notification";
 
-import * as main from "~/store/tinybase/store/main";
+import { getAllEvents } from "~/calendar/queries";
 import {
   createListenerStore,
   type ListenerStore,
@@ -56,29 +56,27 @@ export const useListener = <T,>(
   return useStore(store, useShallow(selector));
 };
 
-function getNearbyEvents(
-  tinybaseStore: NonNullable<ReturnType<typeof main.UI.useStore>>,
-): { id: string; title: string }[] {
+async function getNearbyEvents(): Promise<{ id: string; title: string }[]> {
   const now = Date.now();
   const windowMs = 15 * 60 * 1000;
+  const allEvents = await getAllEvents();
   const results: { id: string; title: string; startedAt: number }[] = [];
 
-  tinybaseStore.forEachRow("events", (eventId, _forEachCell) => {
-    const event = tinybaseStore.getRow("events", eventId);
-    if (!event?.started_at) return;
-    if (event.is_all_day) return;
+  for (const event of allEvents) {
+    if (!event.startedAt) continue;
+    if (event.isAllDay) continue;
 
-    const startTime = new Date(String(event.started_at)).getTime();
-    if (isNaN(startTime)) return;
+    const startTime = new Date(event.startedAt).getTime();
+    if (isNaN(startTime)) continue;
 
     if (Math.abs(startTime - now) <= windowMs) {
       results.push({
-        id: eventId,
-        title: String(event.title || "Untitled Event"),
+        id: event.id,
+        title: event.title || "Untitled Event",
         startedAt: startTime,
       });
     }
-  });
+  }
 
   results.sort((a, b) => a.startedAt - b.startedAt);
   return results.map(({ id, title }) => ({ id, title }));
@@ -87,12 +85,6 @@ function getNearbyEvents(
 const useHandleDetectEvents = (store: ListenerStore) => {
   const stop = useStore(store, (state) => state.stop);
   const setMuted = useStore(store, (state) => state.setMuted);
-  const tinybaseStore = main.UI.useStore(main.STORE_ID);
-
-  const tinybaseStoreRef = useRef(tinybaseStore);
-  useEffect(() => {
-    tinybaseStoreRef.current = tinybaseStore;
-  }, [tinybaseStore]);
 
   useEffect(() => {
     let unlisten: (() => void) | undefined;
@@ -105,43 +97,41 @@ const useHandleDetectEvents = (store: ListenerStore) => {
             return;
           }
 
-          const currentTinybaseStore = tinybaseStoreRef.current;
-          const nearbyEvents = currentTinybaseStore
-            ? getNearbyEvents(currentTinybaseStore)
-            : [];
-          const ignorableAppIds = getIgnorableAppIds(payload.apps);
-
-          const options =
-            nearbyEvents.length > 0 ? nearbyEvents.map((e) => e.title) : null;
-          const footer =
-            ignorableAppIds.length > 0
-              ? {
-                  text:
-                    ignorableAppIds.length === 1
-                      ? "Ignore this app?"
-                      : "Ignore these apps?",
-                  actionLabel: "Yes",
-                }
-              : null;
-
-          void notificationCommands.showNotification({
-            key: payload.key,
-            title: "Are you in a meeting?",
-            message: "",
-            timeout: { secs: 15, nanos: 0 },
-            source: {
-              type: "mic_detected",
-              app_names: payload.apps.map((a) => a.name),
-              app_ids: ignorableAppIds,
-              event_ids: nearbyEvents.map((e) => e.id),
-            },
-            start_time: null,
-            participants: null,
-            event_details: null,
-            action_label: null,
-            options,
-            footer,
-            icon: null,
+          void getNearbyEvents().then((nearbyEvents) => {
+            const ignorableAppIds = getIgnorableAppIds(payload.apps);
+
+            const options =
+              nearbyEvents.length > 0 ? nearbyEvents.map((e) => e.title) : null;
+            const footer =
+              ignorableAppIds.length > 0
+                ? {
+                    text:
+                      ignorableAppIds.length === 1
+                        ? "Ignore this app?"
+                        : "Ignore these apps?",
+                    actionLabel: "Yes",
+                  }
+                : null;
+
+            void notificationCommands.showNotification({
+              key: payload.key,
+              title: "Are you in a meeting?",
+              message: "",
+              timeout: { secs: 15, nanos: 0 },
+              source: {
+                type: "mic_detected",
+                app_names: payload.apps.map((a) => a.name),
+                app_ids: ignorableAppIds,
+                event_ids: nearbyEvents.map((e) => e.id),
+              },
+              start_time: null,
+              participants: null,
+              event_details: null,
+              action_label: null,
+              options,
+              footer,
+              icon: null,
+            });
           });
         } else if (payload.type === "micStopped") {
           stop();
diff --git a/crates/db-app/migrations/20260414120000_calendars_events.sql b/crates/db-app/migrations/20260414120000_calendars_events.sql
new file mode 100644
index 0000000000..8febcf2f74
--- /dev/null
+++ b/crates/db-app/migrations/20260414120000_calendars_events.sql
@@ -0,0 +1,36 @@
+CREATE TABLE IF NOT EXISTS calendars (
+  id                    TEXT PRIMARY KEY NOT NULL,
+  tracking_id_calendar  TEXT NOT NULL DEFAULT '',
+  name                  TEXT NOT NULL DEFAULT '',
+  enabled               INTEGER NOT NULL DEFAULT 0,
+  provider              TEXT NOT NULL DEFAULT '',
+  source                TEXT NOT NULL DEFAULT '',
+  color                 TEXT NOT NULL DEFAULT '#888',
+  connection_id         TEXT NOT NULL DEFAULT '',
+  created_at            TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+  updated_at            TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  id                    TEXT PRIMARY KEY NOT NULL,
+  tracking_id_event     TEXT NOT NULL DEFAULT '',
+  calendar_id           TEXT NOT NULL DEFAULT '',
+  title                 TEXT NOT NULL DEFAULT '',
+  started_at            TEXT NOT NULL DEFAULT '',
+  ended_at              TEXT NOT NULL DEFAULT '',
+  location              TEXT NOT NULL DEFAULT '',
+  meeting_link          TEXT NOT NULL DEFAULT '',
+  description           TEXT NOT NULL DEFAULT '',
+  note                  TEXT NOT NULL DEFAULT '',
+  recurrence_series_id  TEXT NOT NULL DEFAULT '',
+  has_recurrence_rules  INTEGER NOT NULL DEFAULT 0,
+  is_all_day            INTEGER NOT NULL DEFAULT 0,
+  provider              TEXT NOT NULL DEFAULT '',
+  participants_json     TEXT,
+  created_at            TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+  updated_at            TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ', 'now'))
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_calendar_id ON events(calendar_id);
+CREATE INDEX IF NOT EXISTS idx_events_started_at ON events(started_at);
+CREATE INDEX IF NOT EXISTS idx_calendars_provider ON calendars(provider);
diff --git a/crates/db-app/src/calendar_ops.rs b/crates/db-app/src/calendar_ops.rs
new file mode 100644
index 0000000000..8cdc11478b
--- /dev/null
+++ b/crates/db-app/src/calendar_ops.rs
@@ -0,0 +1,83 @@
+use sqlx::SqlitePool;
+
+use crate::{CalendarRow, UpsertCalendar};
+
+pub async fn get_calendar(pool: &SqlitePool, id: &str) -> Result<Option<CalendarRow>, sqlx::Error> {
+    sqlx::query_as::<_, CalendarRow>("SELECT * FROM calendars WHERE id = ?")
+        .bind(id)
+        .fetch_optional(pool)
+        .await
+}
+
+pub async fn list_calendars(pool: &SqlitePool) -> Result<Vec<CalendarRow>, sqlx::Error> {
+    sqlx::query_as::<_, CalendarRow>("SELECT * FROM calendars ORDER BY name")
+        .fetch_all(pool)
+        .await
+}
+
+pub async fn upsert_calendar(
+    pool: &SqlitePool,
+    input: UpsertCalendar<'_>,
+) -> Result<(), sqlx::Error> {
+    sqlx::query(
+        "INSERT INTO calendars \
+         (id, tracking_id_calendar, name, enabled, provider, source, color, connection_id, updated_at) \
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%SZ', 'now')) \
+         ON CONFLICT(id) DO UPDATE SET \
+           tracking_id_calendar = excluded.tracking_id_calendar, \
+           name = excluded.name, \
+           enabled = excluded.enabled, \
+           provider = excluded.provider, \
+           source = excluded.source, \
+           color = excluded.color, \
+           connection_id = excluded.connection_id, \
+           updated_at = excluded.updated_at",
+    )
+    .bind(input.id)
+    .bind(input.tracking_id_calendar)
+    .bind(input.name)
+    .bind(input.enabled)
+    .bind(input.provider)
+    .bind(input.source)
+    .bind(input.color)
+    .bind(input.connection_id)
+    .execute(pool)
+    .await?;
+
+    Ok(())
+}
+
+pub async fn insert_calendar_if_missing(
+    pool: &SqlitePool,
+    input: UpsertCalendar<'_>,
+) -> Result<bool, sqlx::Error> {
+    let result = sqlx::query(
+        "INSERT INTO calendars \
+         (id, tracking_id_calendar, name, enabled, provider, source, color, connection_id, \
+          created_at, updated_at) \
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, \
+          strftime('%Y-%m-%dT%H:%M:%SZ', 'now'), strftime('%Y-%m-%dT%H:%M:%SZ', 'now')) \
+         ON CONFLICT(id) DO NOTHING",
+    )
+    .bind(input.id)
+    .bind(input.tracking_id_calendar)
+    .bind(input.name)
+    .bind(input.enabled)
+    .bind(input.provider)
+    .bind(input.source)
+    .bind(input.color)
+    .bind(input.connection_id)
+    .execute(pool)
+    .await?;
+
+    Ok(result.rows_affected() > 0)
+}
+
+pub async fn delete_calendar(pool: &SqlitePool, id: &str) -> Result<(), sqlx::Error> {
+    sqlx::query("DELETE FROM calendars WHERE id = ?")
+        .bind(id)
+        .execute(pool)
+        .await?;
+
+    Ok(())
+}
diff --git a/crates/db-app/src/calendar_types.rs b/crates/db-app/src/calendar_types.rs
new file mode 100644
index 0000000000..6e5340cf78
--- /dev/null
+++ b/crates/db-app/src/calendar_types.rs
@@ -0,0 +1,24 @@
+#[derive(Debug, Clone, PartialEq, Eq, sqlx::FromRow)]
+pub struct CalendarRow {
+    pub id: String,
+    pub tracking_id_calendar: String,
+    pub name: String,
+    pub enabled: bool,
+    pub provider: String,
+    pub source: String,
+    pub color: String,
+    pub connection_id: String,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+pub struct UpsertCalendar<'a> {
+    pub id: &'a str,
+    pub tracking_id_calendar: &'a str,
+    pub name: &'a str,
+    pub enabled: bool,
+    pub provider: &'a str,
+    pub source: &'a str,
+    pub color: &'a str,
+    pub connection_id: &'a str,
+}
diff --git a/crates/db-app/src/event_ops.rs b/crates/db-app/src/event_ops.rs
new file mode 100644
index 0000000000..6f9bab4a06
--- /dev/null
+++ b/crates/db-app/src/event_ops.rs
@@ -0,0 +1,117 @@
+use sqlx::SqlitePool;
+
+use crate::{EventRow, UpsertEvent};
+
+pub async fn get_event(pool: &SqlitePool, id: &str) -> Result<Option<EventRow>, sqlx::Error> {
+    sqlx::query_as::<_, EventRow>("SELECT * FROM events WHERE id = ?")
+        .bind(id)
+        .fetch_optional(pool)
+        .await
+}
+
+pub async fn list_events(pool: &SqlitePool) -> Result<Vec<EventRow>, sqlx::Error> {
+    sqlx::query_as::<_, EventRow>("SELECT * FROM events ORDER BY started_at")
+        .fetch_all(pool)
+        .await
+}
+
+pub async fn upsert_event(pool: &SqlitePool, input: UpsertEvent<'_>) -> Result<(), sqlx::Error> {
+    sqlx::query(
+        "INSERT INTO events \
+         (id, tracking_id_event, calendar_id, title, started_at, ended_at, \
+          location, meeting_link, description, note, recurrence_series_id, \
+          has_recurrence_rules, is_all_day, provider, participants_json, updated_at) \
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%SZ', 'now')) \
+         ON CONFLICT(id) DO UPDATE SET \
+           tracking_id_event = excluded.tracking_id_event, \
+           calendar_id = excluded.calendar_id, \
+           title = excluded.title, \
+           started_at = excluded.started_at, \
+           ended_at = excluded.ended_at, \
+           location = excluded.location, \
+           meeting_link = excluded.meeting_link, \
+           description = excluded.description, \
+           note = excluded.note, \
+           recurrence_series_id = excluded.recurrence_series_id, \
+           has_recurrence_rules = excluded.has_recurrence_rules, \
+           is_all_day = excluded.is_all_day, \
+           provider = excluded.provider, \
+           participants_json = excluded.participants_json, \
+           updated_at = excluded.updated_at",
+    )
+    .bind(input.id)
+    .bind(input.tracking_id_event)
+    .bind(input.calendar_id)
+    .bind(input.title)
+    .bind(input.started_at)
+    .bind(input.ended_at)
+    .bind(input.location)
+    .bind(input.meeting_link)
+    .bind(input.description)
+    .bind(input.note)
+    .bind(input.recurrence_series_id)
+    .bind(input.has_recurrence_rules)
+    .bind(input.is_all_day)
+    .bind(input.provider)
+    .bind(input.participants_json)
+    .execute(pool)
+    .await?;
+
+    Ok(())
+}
+
+pub async fn insert_event_if_missing(
+    pool: &SqlitePool,
+    input: UpsertEvent<'_>,
+) -> Result<bool, sqlx::Error> {
+    let result = sqlx::query(
+        "INSERT INTO events \
+         (id, tracking_id_event, calendar_id, title, started_at, ended_at, \
+          location, meeting_link, description, note, recurrence_series_id, \
+          has_recurrence_rules, is_all_day, provider, participants_json, \
+          created_at, updated_at) \
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, \
+          strftime('%Y-%m-%dT%H:%M:%SZ', 'now'), strftime('%Y-%m-%dT%H:%M:%SZ', 'now')) \
+         ON CONFLICT(id) DO NOTHING",
+    )
+    .bind(input.id)
+    .bind(input.tracking_id_event)
+    .bind(input.calendar_id)
+    .bind(input.title)
+    .bind(input.started_at)
+    .bind(input.ended_at)
+    .bind(input.location)
+    .bind(input.meeting_link)
+    .bind(input.description)
+    .bind(input.note)
+    .bind(input.recurrence_series_id)
+    .bind(input.has_recurrence_rules)
+    .bind(input.is_all_day)
+    .bind(input.provider)
+    .bind(input.participants_json)
+    .execute(pool)
+    .await?;
+
+    Ok(result.rows_affected() > 0)
+}
+
+pub async fn delete_event(pool: &SqlitePool, id: &str) -> Result<(), sqlx::Error> {
+    sqlx::query("DELETE FROM events WHERE id = ?")
+        .bind(id)
+        .execute(pool)
+        .await?;
+
+    Ok(())
+}
+
+pub async fn delete_events_by_calendar_id(
+    pool: &SqlitePool,
+    calendar_id: &str,
+) -> Result<u64, sqlx::Error> {
+    let result = sqlx::query("DELETE FROM events WHERE calendar_id = ?")
+        .bind(calendar_id)
+        .execute(pool)
+        .await?;
+
+    Ok(result.rows_affected())
+}
diff --git a/crates/db-app/src/event_types.rs b/crates/db-app/src/event_types.rs
new file mode 100644
index 0000000000..e8bb025cf4
--- /dev/null
+++ b/crates/db-app/src/event_types.rs
@@ -0,0 +1,38 @@
+#[derive(Debug, Clone, PartialEq, Eq, sqlx::FromRow)]
+pub struct EventRow {
+    pub id: String,
+    pub tracking_id_event: String,
+    pub calendar_id: String,
+    pub title: String,
+    pub started_at: String,
+    pub ended_at: String,
+    pub location: String,
+    pub meeting_link: String,
+    pub description: String,
+    pub note: String,
+    pub recurrence_series_id: String,
+    pub has_recurrence_rules: bool,
+    pub is_all_day: bool,
+    pub provider: String,
+    pub participants_json: Option<String>,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+pub struct UpsertEvent<'a> {
+    pub id: &'a str,
+    pub tracking_id_event: &'a str,
+    pub calendar_id: &'a str,
+    pub title: &'a str,
+    pub started_at: &'a str,
+    pub ended_at: &'a str,
+    pub location: &'a str,
+    pub meeting_link: &'a str,
+    pub description: &'a str,
+    pub note: &'a str,
+    pub recurrence_series_id: &'a str,
+    pub has_recurrence_rules: bool,
+    pub is_all_day: bool,
+    pub provider: &'a str,
+    pub participants_json: Option<&'a str>,
+}
diff --git a/crates/db-app/src/lib.rs b/crates/db-app/src/lib.rs
index e45c8d21c4..d5829dfc26 100644
--- a/crates/db-app/src/lib.rs
+++ b/crates/db-app/src/lib.rs
@@ -7,8 +7,6 @@ mod daily_note_ops;
 mod daily_note_types;
 mod daily_summary_ops;
 mod daily_summary_types;
-mod prompt_override_ops;
-mod prompt_override_types;
 mod template_ops;
 mod template_types;
 
@@ -19,8 +17,6 @@ pub use daily_note_ops::*;
 pub use daily_note_types::*;
 pub use daily_summary_ops::*;
 pub use daily_summary_types::*;
-pub use prompt_override_ops::*;
-pub use prompt_override_types::*;
 pub use template_ops::*;
 pub use template_types::*;
 
@@ -64,7 +60,6 @@ mod tests {
                 "activity_screenshots",
                 "daily_notes",
                 "daily_summaries",
-                "prompt_overrides",
                 "templates",
             ]
         );
@@ -281,87 +276,6 @@ mod tests {
         assert!(get_daily_summary(db.pool(), "ds1").await.unwrap().is_none());
     }
 
-    #[tokio::test]
-    async fn prompt_override_roundtrip() {
-        let db = test_db().await;
-
-        upsert_prompt_override(
-            db.pool(),
-            UpsertPromptOverride {
-                task_type: "enhance",
-                content: "# Context",
-            },
-        )
-        .await
-        .unwrap();
-
-        let row = get_prompt_override(db.pool(), "enhance")
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(row.task_type, "enhance");
-        assert_eq!(row.content, "# Context");
-
-        let rows = list_prompt_overrides(db.pool()).await.unwrap();
-        assert_eq!(rows.len(), 1);
-        assert_eq!(rows[0].task_type, "enhance");
-    }
-
-    #[tokio::test]
-    async fn prompt_override_upsert_replaces_existing_row() {
-        let db = test_db().await;
-
-        upsert_prompt_override(
-            db.pool(),
-            UpsertPromptOverride {
-                task_type: "title",
-                content: "first",
-            },
-        )
-        .await
-        .unwrap();
-
-        upsert_prompt_override(
-            db.pool(),
-            UpsertPromptOverride {
-                task_type: "title",
-                content: "second",
-            },
-        )
-        .await
-        .unwrap();
-
-        let row = get_prompt_override(db.pool(), "title")
-            .await
-            .unwrap()
-            .unwrap();
-        assert_eq!(row.content, "second");
-        assert_eq!(list_prompt_overrides(db.pool()).await.unwrap().len(), 1);
-    }
-
-    #[tokio::test]
-    async fn prompt_override_delete_removes_row() {
-        let db = test_db().await;
-
-        upsert_prompt_override(
-            db.pool(),
-            UpsertPromptOverride {
-                task_type: "enhance",
-                content: "value",
-            },
-        )
-        .await
-        .unwrap();
-
-        delete_prompt_override(db.pool(), "enhance").await.unwrap();
-        assert!(
-            get_prompt_override(db.pool(), "enhance")
-                .await
-                .unwrap()
-                .is_none()
-        );
-    }
-
     #[tokio::test]
     async fn template_roundtrip() {
         let db = test_db().await;
diff --git a/packages/db/src/index.ts b/packages/db/src/index.ts
index d11393e4d6..81279a19a0 100644
--- a/packages/db/src/index.ts
+++ b/packages/db/src/index.ts
@@ -19,4 +19,17 @@ export function createDb(client: DrizzleProxyClient) {
 }
 
 export * from "./schema";
-export { eq, and, or, desc, asc, sql, count, max, ne } from "drizzle-orm";
+export {
+  eq,
+  and,
+  or,
+  desc,
+  asc,
+  sql,
+  count,
+  max,
+  ne,
+  gte,
+  lte,
+  inArray,
+} from "drizzle-orm";
diff --git a/packages/db/src/schema.ts b/packages/db/src/schema.ts
index b2319d52aa..569fdf61f5 100644
--- a/packages/db/src/schema.ts
+++ b/packages/db/src/schema.ts
@@ -138,6 +138,54 @@ export const activityObservationAnalyses = sqliteTable(
   ],
 );
 
+export const calendars = sqliteTable(
+  "calendars",
+  {
+    id: text("id").primaryKey(),
+    trackingIdCalendar: text("tracking_id_calendar").notNull().default(""),
+    name: text("name").notNull().default(""),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(false),
+    provider: text("provider").notNull().default(""),
+    source: text("source").notNull().default(""),
+    color: text("color").notNull().default("#888"),
+    connectionId: text("connection_id").notNull().default(""),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (table) => [index("idx_calendars_provider").on(table.provider)],
+);
+
+export const events = sqliteTable(
+  "events",
+  {
+    id: text("id").primaryKey(),
+    trackingIdEvent: text("tracking_id_event").notNull().default(""),
+    calendarId: text("calendar_id").notNull().default(""),
+    title: text("title").notNull().default(""),
+    startedAt: text("started_at").notNull().default(""),
+    endedAt: text("ended_at").notNull().default(""),
+    location: text("location").notNull().default(""),
+    meetingLink: text("meeting_link").notNull().default(""),
+    description: text("description").notNull().default(""),
+    note: text("note").notNull().default(""),
+    recurrenceSeriesId: text("recurrence_series_id").notNull().default(""),
+    hasRecurrenceRules: integer("has_recurrence_rules", { mode: "boolean" })
+      .notNull()
+      .default(false),
+    isAllDay: integer("is_all_day", { mode: "boolean" })
+      .notNull()
+      .default(false),
+    provider: text("provider").notNull().default(""),
+    participantsJson: text("participants_json", { mode: "json" }),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (table) => [
+    index("idx_events_calendar_id").on(table.calendarId),
+    index("idx_events_started_at").on(table.startedAt),
+  ],
+);
+
 export const promptOverrides = sqliteTable("prompt_overrides", {
   taskType: text("task_type").primaryKey(),
   content: text("content").notNull().default(""),
diff --git a/packages/store/src/tinybase.ts b/packages/store/src/tinybase.ts
index 5a99ee9c12..b2d1a6bb3f 100644
--- a/packages/store/src/tinybase.ts
+++ b/packages/store/src/tinybase.ts
@@ -2,13 +2,11 @@ import type { TablesSchema } from "tinybase/with-schemas";
 
 import type { InferTinyBaseSchema } from "./shared";
 import {
-  calendarSchema,
   chatGroupSchema,
   chatMessageSchema,
   chatShortcutSchema,
   dailyNoteSchema,
   enhancedNoteSchema,
-  eventSchema,
   generalSchema,
   humanSchema,
   mappingMentionSchema,
@@ -60,35 +58,6 @@ export const tableSchemaForTinybase = {
     pinned: { type: "boolean" },
     pin_order: { type: "number" },
   } as const satisfies InferTinyBaseSchema<typeof organizationSchema>,
-  calendars: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    tracking_id_calendar: { type: "string" },
-    name: { type: "string" },
-    enabled: { type: "boolean" },
-    provider: { type: "string" },
-    source: { type: "string" },
-    color: { type: "string" },
-    connection_id: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof calendarSchema>,
-  events: {
-    user_id: { type: "string" },
-    created_at: { type: "string" },
-    tracking_id_event: { type: "string" },
-    calendar_id: { type: "string" },
-    title: { type: "string" },
-    started_at: { type: "string" },
-    ended_at: { type: "string" },
-    location: { type: "string" },
-    meeting_link: { type: "string" },
-    description: { type: "string" },
-    note: { type: "string" },
-    recurrence_series_id: { type: "string" },
-    has_recurrence_rules: { type: "boolean" },
-    is_all_day: { type: "boolean" },
-    provider: { type: "string" },
-    participants_json: { type: "string" },
-  } as const satisfies InferTinyBaseSchema<typeof eventSchema>,
   mapping_session_participant: {
     user_id: { type: "string" },
     session_id: { type: "string" },
diff --git a/plugins/db/src/import/calendars.rs b/plugins/db/src/import/calendars.rs
new file mode 100644
index 0000000000..c3593b09c6
--- /dev/null
+++ b/plugins/db/src/import/calendars.rs
@@ -0,0 +1,95 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use hypr_db_app::UpsertCalendar;
+use sqlx::SqlitePool;
+
+pub async fn import_legacy_calendars_from_path(
+    pool: &SqlitePool,
+    path: &Path,
+) -> crate::Result<()> {
+    if !path.exists() {
+        return Ok(());
+    }
+
+    let calendars = read_calendars_file(path)?;
+    for cal in calendars {
+        hypr_db_app::insert_calendar_if_missing(
+            pool,
+            UpsertCalendar {
+                id: &cal.id,
+                tracking_id_calendar: &cal.tracking_id_calendar,
+                name: &cal.name,
+                enabled: cal.enabled,
+                provider: &cal.provider,
+                source: &cal.source,
+                color: &cal.color,
+                connection_id: &cal.connection_id,
+            },
+        )
+        .await?;
+    }
+
+    Ok(())
+}
+
+struct LegacyCalendar {
+    id: String,
+    tracking_id_calendar: String,
+    name: String,
+    enabled: bool,
+    provider: String,
+    source: String,
+    color: String,
+    connection_id: String,
+}
+
+fn read_calendars_file(path: &Path) -> crate::Result<Vec<LegacyCalendar>> {
+    let content = std::fs::read_to_string(path)?;
+    let Ok(table) = serde_json::from_str::<HashMap<String, serde_json::Value>>(&content) else {
+        return Ok(Vec::new());
+    };
+
+    let mut calendars = Vec::new();
+    for (id, row) in table {
+        calendars.push(LegacyCalendar {
+            id,
+            tracking_id_calendar: row
+                .get("tracking_id_calendar")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string(),
+            name: row
+                .get("name")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string(),
+            enabled: row
+                .get("enabled")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false),
+            provider: row
+                .get("provider")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string(),
+            source: row
+                .get("source")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string(),
+            color: row
+                .get("color")
+                .and_then(|v| v.as_str())
+                .unwrap_or("#888")
+                .to_string(),
+            connection_id: row
+                .get("connection_id")
+                .and_then(|v| v.as_str())
+                .unwrap_or("")
+                .to_string(),
+        });
+    }
+
+    Ok(calendars)
+}
diff --git a/plugins/db/src/import/events.rs b/plugins/db/src/import/events.rs
new file mode 100644
index 0000000000..4288b8dfbd
--- /dev/null
+++ b/plugins/db/src/import/events.rs
@@ -0,0 +1,104 @@
+use std::collections::HashMap;
+use std::path::Path;
+
+use hypr_db_app::UpsertEvent;
+use sqlx::SqlitePool;
+
+pub async fn import_legacy_events_from_path(pool: &SqlitePool, path: &Path) -> crate::Result<()> {
+    if !path.exists() {
+        return Ok(());
+    }
+
+    let events = read_events_file(path)?;
+    for event in events {
+        hypr_db_app::insert_event_if_missing(
+            pool,
+            UpsertEvent {
+                id: &event.id,
+                tracking_id_event: &event.tracking_id_event,
+                calendar_id: &event.calendar_id,
+                title: &event.title,
+                started_at: &event.started_at,
+                ended_at: &event.ended_at,
+                location: &event.location,
+                meeting_link: &event.meeting_link,
+                description: &event.description,
+                note: &event.note,
+                recurrence_series_id: &event.recurrence_series_id,
+                has_recurrence_rules: event.has_recurrence_rules,
+                is_all_day: event.is_all_day,
+                provider: &event.provider,
+                participants_json: event.participants_json.as_deref(),
+            },
+        )
+        .await?;
+    }
+
+    Ok(())
+}
+
+struct LegacyEvent {
+    id: String,
+    tracking_id_event: String,
+    calendar_id: String,
+    title: String,
+    started_at: String,
+    ended_at: String,
+    location: String,
+    meeting_link: String,
+    description: String,
+    note: String,
+    recurrence_series_id: String,
+    has_recurrence_rules: bool,
+    is_all_day: bool,
+    provider: String,
+    participants_json: Option<String>,
+}
+
+fn str_field(row: &serde_json::Value, key: &str) -> String {
+    row.get(key)
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string()
+}
+
+fn bool_field(row: &serde_json::Value, key: &str) -> bool {
+    row.get(key).and_then(|v| v.as_bool()).unwrap_or(false)
+}
+
+fn read_events_file(path: &Path) -> crate::Result<Vec<LegacyEvent>> {
+    let content = std::fs::read_to_string(path)?;
+    let Ok(table) = serde_json::from_str::<HashMap<String, serde_json::Value>>(&content) else {
+        return Ok(Vec::new());
+    };
+
+    let mut events = Vec::new();
+    for (id, row) in table {
+        // In events.json, the persister saves `participants_json` as `participants` (parsed JSON).
+        // We need to re-serialize it back to a JSON string.
+        let participants_json = row
+            .get("participants")
+            .filter(|v| !v.is_null())
+            .map(|v| v.to_string());
+
+        events.push(LegacyEvent {
+            id,
+            tracking_id_event: str_field(&row, "tracking_id_event"),
+            calendar_id: str_field(&row, "calendar_id"),
+            title: str_field(&row, "title"),
+            started_at: str_field(&row, "started_at"),
+            ended_at: str_field(&row, "ended_at"),
+            location: str_field(&row, "location"),
+            meeting_link: str_field(&row, "meeting_link"),
+            description: str_field(&row, "description"),
+            note: str_field(&row, "note"),
+            recurrence_series_id: str_field(&row, "recurrence_series_id"),
+            has_recurrence_rules: bool_field(&row, "has_recurrence_rules"),
+            is_all_day: bool_field(&row, "is_all_day"),
+            provider: str_field(&row, "provider"),
+            participants_json,
+        });
+    }
+
+    Ok(events)
+}