diff --git a/.agents/skills/migrate-to-sqlite/SKILL.md b/.agents/skills/migrate-to-sqlite/SKILL.md
index 2d9fbb02a6..cb8a0edc6b 100644
--- a/.agents/skills/migrate-to-sqlite/SKILL.md
+++ b/.agents/skills/migrate-to-sqlite/SKILL.md
@@ -8,39 +8,68 @@ description: Migrate a TinyBase table to SQLite. Use when asked to move a data d
 Keep up to date as each PR lands. Outer box = fully done across both
 phases. Sub-bullets track sub-states where relevant.
 
+Phase 0 is essentially complete — every non-entrypoint consumer of the
+main TinyBase store's `UI.*` surface goes through `~/<domain>/hooks*`.
+`apps/desktop/src/main.tsx` (the app entry wiring up the
+`TinyBaseProvider`) is the only consumer that still touches `UI.*`
+directly.
+
+Non-UI imperative helpers (`store/sessions`, `store/save`,
+`store/deleteSession`, `store/importer`, `store/settings`, `persister/*`)
+are still imported directly from a handful of consumer files. These are
+outside phase-0 scope — phase 0 targets reactive UI access only — and
+the `hypr/no-raw-tinybase` rule permits them.
+
 - [x] `templates` — already Drizzle, no Phase 0 needed
 - [ ] `calendars`
-  - [x] Phase 0 reads (PR 2: `useCalendar`, `useEnabledCalendars`)
-  - [ ] Phase 0 writes — `services/calendar/ctx.ts` has a cross-domain
-        calendars+events transaction; lands with events PR
+  - [x] Phase 0 — `calendar/hooks.ts`
   - [ ] Phase 1 — Rust migration + ops exist
 - [ ] `events`
-  - [ ] Phase 0
+  - [x] Phase 0 — `calendar/hooks.ts` + `services/calendar/*` (sync via `ctx.store`)
   - [ ] Phase 1 — Rust migration + ops exist
 - [ ] `sessions`
+  - [x] Phase 0 — `session/hooks/storage.ts` used by session UI, STT, sidebar, main2/home, editor, services
+  - [ ] Phase 1
 - [ ] `transcripts`
+  - [x] Phase 0 — `session/hooks/storage.ts` + STT hooks
+  - [ ] Phase 1
 - [ ] `humans`
+  - [x] Phase 0 — `contacts/hooks.ts`
+  - [ ] Phase 1
 - [ ] `organizations`
+  - [x] Phase 0 — `contacts/hooks.ts`
+  - [ ] Phase 1
 - [ ] `enhanced_notes`
-  - [x] Phase 0 reads — `session/hooks/useEnhancedNotes.ts`
-  - [ ] Phase 0 writes
+  - [x] Phase 0 — `session/hooks/useEnhancedNotes.ts` + `session/hooks/storage.ts`
   - [ ] Phase 1
 - [ ] `mapping_session_participant`
+  - [x] Phase 0 — `session/hooks/storage.ts` (reads + writes)
+  - [ ] Phase 1
 - [ ] `mapping_tag_session`
+  - [x] Phase 0 — `session/hooks/storage.ts`
+  - [ ] Phase 1
 - [ ] `mapping_mention`
 - [ ] `tags`
+  - [x] Phase 0 — `session/hooks/storage.ts`
+  - [ ] Phase 1
 - [ ] `chat_groups`
+  - [x] Phase 0 — `chat/hooks/chat-groups.ts`
+  - [ ] Phase 1
 - [ ] `chat_messages`
-  - [x] Phase 0 writes (partial) — `chat/store/*`
-  - [ ] Phase 0 reads
+  - [x] Phase 0 — `chat/hooks/*`
   - [ ] Phase 1
 - [ ] `chat_shortcuts`
+  - [x] Phase 0 — `chat_shortcuts/hooks.ts`
+  - [ ] Phase 1
 - [ ] `tasks`
+  - [x] Phase 0 — `tasks/hooks.tsx`
+  - [ ] Phase 1
 - [ ] `memories`
-  - [x] Phase 0 writes — `settings/memory/custom-vocabulary.tsx`
-  - [ ] Phase 0 reads
+  - [x] Phase 0 — `settings/memory/hooks.ts`
   - [ ] Phase 1
 - [ ] `daily_notes`
+  - [x] Phase 0 — `session/hooks/storage.ts` (`useUpdateDailyNoteContent`) + `main2/home/note-editor.tsx` uses it
+  - [ ] Phase 1
 
 ## Strategy
 
diff --git a/.oxlintrc.json b/.oxlintrc.json
index 6d85c1adeb..eba8aefd7f 100644
--- a/.oxlintrc.json
+++ b/.oxlintrc.json
@@ -24,9 +24,6 @@
     {
       "files": [
         "apps/desktop/src/store/tinybase/**",
-        "apps/desktop/src/**/hooks/**",
-        "apps/desktop/src/**/hooks.ts",
-        "apps/desktop/src/**/hooks.tsx",
         "apps/desktop/src/**/*.test.ts",
         "apps/desktop/src/**/*.test.tsx",
         "apps/desktop/src/**/*.spec.ts",
@@ -38,35 +35,37 @@
     },
     {
       "files": [
-        "apps/desktop/src/ai/**",
-        "apps/desktop/src/auth/**",
-        "apps/desktop/src/calendar/**",
-        "apps/desktop/src/chat/**",
-        "apps/desktop/src/chat_shortcuts/**",
-        "apps/desktop/src/composer/**",
-        "apps/desktop/src/contacts/**",
-        "apps/desktop/src/edit/**",
-        "apps/desktop/src/editor/**",
-        "apps/desktop/src/folders/**",
-        "apps/desktop/src/main.tsx",
-        "apps/desktop/src/main/**",
-        "apps/desktop/src/main2/**",
-        "apps/desktop/src/onboarding/**",
-        "apps/desktop/src/search/**",
-        "apps/desktop/src/services/**",
-        "apps/desktop/src/session/**",
-        "apps/desktop/src/settings/**",
-        "apps/desktop/src/shared/**",
-        "apps/desktop/src/sidebar/**",
-        "apps/desktop/src/store/zustand/**",
-        "apps/desktop/src/stt/**",
-        "apps/desktop/src/templates/template-body.tsx",
-        "apps/desktop/src/templates/template-form.tsx",
-        "apps/desktop/src/templates/utils.ts"
+        "apps/desktop/src/session/hooks/storage.ts",
+        "apps/desktop/src/session/hooks/internal.ts",
+        "apps/desktop/src/session/hooks/queries.ts",
+        "apps/desktop/src/session/hooks/sessions.ts",
+        "apps/desktop/src/session/hooks/participants.ts",
+        "apps/desktop/src/session/hooks/tags.ts",
+        "apps/desktop/src/session/hooks/search.ts",
+        "apps/desktop/src/session/hooks/transcripts.ts",
+        "apps/desktop/src/session/hooks/runtime.ts",
+        "apps/desktop/src/session/hooks/enhanced-notes.ts",
+        "apps/desktop/src/session/hooks/useEnhancedNotes.ts",
+        "apps/desktop/src/calendar/hooks.ts",
+        "apps/desktop/src/contacts/hooks.ts",
+        "apps/desktop/src/chat_shortcuts/hooks.ts",
+        "apps/desktop/src/chat/hooks/useCreateChatMessage.ts",
+        "apps/desktop/src/chat/hooks/use-chat-actions.ts",
+        "apps/desktop/src/chat/hooks/persisted-messages.ts",
+        "apps/desktop/src/chat/hooks/chat-messages.ts",
+        "apps/desktop/src/chat/hooks/chat-groups.ts",
+        "apps/desktop/src/settings/memory/hooks.ts",
+        "apps/desktop/src/tasks/hooks.tsx"
       ],
       "rules": {
         "hypr/no-raw-tinybase": "off"
       }
+    },
+    {
+      "files": ["apps/desktop/src/main.tsx"],
+      "rules": {
+        "hypr/no-raw-tinybase": "off"
+      }
     }
   ]
 }
diff --git a/apps/desktop/src/calendar/components/apple/calendar-selection.tsx b/apps/desktop/src/calendar/components/apple/calendar-selection.tsx
index b5e48181af..0b6849d29e 100644
--- a/apps/desktop/src/calendar/components/apple/calendar-selection.tsx
+++ b/apps/desktop/src/calendar/components/apple/calendar-selection.tsx
@@ -7,8 +7,11 @@ import {
   type CalendarItem,
   CalendarSelection,
 } from "~/calendar/components/calendar-selection";
+import {
+  useCalendarsByProvider,
+  useSetCalendarEnabled,
+} from "~/calendar/hooks";
 import { useMountEffect } from "~/shared/hooks/useMountEffect";
-import * as main from "~/store/tinybase/store/main";
 
 const SUBSCRIBED_SOURCE_NAME = "Subscribed Calendars";
 
@@ -43,23 +46,19 @@ 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 calendars = useCalendarsByProvider("apple");
+  const setCalendarEnabled = useSetCalendarEnabled();
 
   const groups = useMemo((): CalendarGroup[] => {
-    const appleCalendars = Object.entries(calendars).filter(
-      ([_, cal]) => cal.provider === "apple",
-    );
-
     const grouped = new Map<string, CalendarItem[]>();
-    for (const [id, cal] of appleCalendars) {
+    for (const cal of calendars) {
       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,
+        enabled: cal.enabled,
       });
     }
 
@@ -77,10 +76,10 @@ export function useAppleCalendarSelection() {
 
   const handleToggle = useCallback(
     (calendar: CalendarItem, enabled: boolean) => {
-      store?.setPartialRow("calendars", calendar.id, { enabled });
+      setCalendarEnabled(calendar.id, enabled);
       scheduleDebouncedSync();
     },
-    [store, scheduleDebouncedSync],
+    [setCalendarEnabled, 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 8036eec954..8acf780df3 100644
--- a/apps/desktop/src/calendar/components/event-chip.tsx
+++ b/apps/desktop/src/calendar/components/event-chip.tsx
@@ -10,11 +10,15 @@ import {
 } from "@hypr/ui/components/ui/popover";
 import { cn } from "@hypr/utils";
 
-import { toTz, useCalendar, useTimezone } from "~/calendar/hooks";
+import {
+  toTz,
+  useCalendar,
+  useEvent,
+  useTimelineEvent,
+  useTimezone,
+} from "~/calendar/hooks";
 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 { useGetOrCreateSessionForEvent } from "~/session/hooks/runtime";
 import { useTabs } from "~/store/zustand/tabs";
 
 function useCalendarColor(calendarId: string | null): string | null {
@@ -24,24 +28,18 @@ function useCalendarColor(calendarId: string | null): string | 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 = useTimelineEvent(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 (
@@ -55,7 +53,7 @@ export function EventChip({ eventId }: { eventId: string }) {
             ])}
             style={{ backgroundColor: color }}
           >
-            {event.title as string}
+            {event.title}
           </button>
         ) : (
           <button
@@ -68,7 +66,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,21 +91,17 @@ export function EventChip({ eventId }: { eventId: string }) {
 
 function EventPopoverContent({ eventId }: { eventId: string }) {
   const event = useEvent(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 eventRow = useTimelineEvent(eventId);
+  const getOrCreateSession = useGetOrCreateSessionForEvent();
 
   const handleOpen = useCallback(() => {
-    if (!store) return;
-    const title = (eventRow?.title as string) || "Untitled";
-    const sessionId = getOrCreateSessionForEventId(store, eventId, title);
-    openNew({ type: "sessions", id: sessionId });
-  }, [store, eventId, eventRow?.title, openNew]);
+    const title = eventRow?.title || "Untitled";
+    const sessionId = getOrCreateSession(eventId, title);
+    if (sessionId) {
+      openNew({ type: "sessions", id: sessionId });
+    }
+  }, [eventId, eventRow?.title, openNew, getOrCreateSession]);
 
   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..7254d78189 100644
--- a/apps/desktop/src/calendar/components/oauth/calendar-selection.tsx
+++ b/apps/desktop/src/calendar/components/oauth/calendar-selection.tsx
@@ -9,7 +9,10 @@ import {
   CalendarSelection,
 } from "~/calendar/components/calendar-selection";
 import type { CalendarProvider } from "~/calendar/components/shared";
-import * as main from "~/store/tinybase/store/main";
+import {
+  useCalendarsByProvider,
+  useSetCalendarEnabled,
+} from "~/calendar/hooks";
 
 export function OAuthCalendarSelection({
   groups,
@@ -34,33 +37,29 @@ 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 providerCalendars = useCalendarsByProvider(config.id);
+  const setCalendarEnabled = useSetCalendarEnabled();
   const { cancelDebouncedSync, status, scheduleDebouncedSync, scheduleSync } =
     useSync();
 
   const { groups, connectionSourceMap } = useMemo(() => {
-    const providerCalendars = Object.entries(calendars).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) {
+      // HACK: derive connectionId -> source mapping from calendar entries
+      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,10 +88,10 @@ export function useOAuthCalendarSelection(config: CalendarProvider) {
         group.connectionId = connectionId;
       }
       group.calendars.push({
-        id,
-        title: cal.name ?? "Untitled",
-        color: cal.color ?? "#4285f4",
-        enabled: cal.enabled ?? false,
+        id: cal.id,
+        title: cal.name || "Untitled",
+        color: cal.color || "#4285f4",
+        enabled: cal.enabled,
       });
     }
 
@@ -105,14 +103,14 @@ export function useOAuthCalendarSelection(config: CalendarProvider) {
       })),
       connectionSourceMap: sourceMap,
     };
-  }, [calendars, config.id]);
+  }, [providerCalendars, config.id, config.displayName]);
 
   const handleToggle = useCallback(
     (calendar: CalendarItem, enabled: boolean) => {
-      store?.setPartialRow("calendars", calendar.id, { enabled });
+      setCalendarEnabled(calendar.id, enabled);
       scheduleDebouncedSync();
     },
-    [store, scheduleDebouncedSync],
+    [setCalendarEnabled, scheduleDebouncedSync],
   );
 
   const handleRefresh = useCallback(() => {
diff --git a/apps/desktop/src/calendar/components/session-chip.tsx b/apps/desktop/src/calendar/components/session-chip.tsx
index a8305430fe..7eb9dd1f78 100644
--- a/apps/desktop/src/calendar/components/session-chip.tsx
+++ b/apps/desktop/src/calendar/components/session-chip.tsx
@@ -10,24 +10,19 @@ import {
 } from "@hypr/ui/components/ui/popover";
 import { cn } from "@hypr/utils";
 
-import { toTz, useTimezone } from "~/calendar/hooks";
-import * as main from "~/store/tinybase/store/main";
+import { toTz, useTimelineSession, useTimezone } from "~/calendar/hooks";
 import { useTabs } from "~/store/zustand/tabs";
 
 export function SessionChip({ sessionId }: { sessionId: string }) {
   const tz = useTimezone();
-  const session = main.UI.useResultRow(
-    main.QUERIES.timelineSessions,
-    sessionId,
-    main.STORE_ID,
-  );
+  const session = useTimelineSession(sessionId);
 
   if (!session || !session.title) {
     return null;
   }
 
-  const createdAt = session.created_at
-    ? format(toTz(session.created_at as string, tz), "h:mm a")
+  const createdAt = session.createdAt
+    ? format(toTz(session.createdAt, tz), "h:mm a")
     : null;
 
   return (
@@ -40,7 +35,7 @@ export function SessionChip({ sessionId }: { sessionId: string }) {
           ])}
         >
           <div className="w-[4px] shrink-0 self-stretch rounded-full border border-neutral-300 bg-transparent" />
-          <span className="truncate">{session.title as string}</span>
+          <span className="truncate">{session.title}</span>
           {createdAt && (
             <span className="ml-auto shrink-0 font-mono text-neutral-400">
               {createdAt}
@@ -63,11 +58,7 @@ export function SessionChip({ sessionId }: { sessionId: string }) {
 }
 
 function SessionPopoverContent({ sessionId }: { sessionId: string }) {
-  const session = main.UI.useResultRow(
-    main.QUERIES.timelineSessions,
-    sessionId,
-    main.STORE_ID,
-  );
+  const session = useTimelineSession(sessionId);
   const openNew = useTabs((state) => state.openNew);
   const tz = useTimezone();
 
@@ -79,14 +70,14 @@ function SessionPopoverContent({ sessionId }: { sessionId: string }) {
     return null;
   }
 
-  const createdAt = session.created_at
-    ? format(toTz(session.created_at as string, tz), "MMM d, yyyy h:mm a")
+  const createdAt = session.createdAt
+    ? format(toTz(session.createdAt, tz), "MMM d, yyyy h:mm a")
     : null;
 
   return (
     <div className="flex flex-col gap-3 p-4">
       <div className="text-base font-medium text-neutral-900">
-        {session.title as string}
+        {session.title}
       </div>
       <div className="h-px bg-neutral-200" />
       {createdAt && <div className="text-sm text-neutral-700">{createdAt}</div>}
diff --git a/apps/desktop/src/calendar/hooks.ts b/apps/desktop/src/calendar/hooks.ts
index 81805dac9a..0810028d45 100644
--- a/apps/desktop/src/calendar/hooks.ts
+++ b/apps/desktop/src/calendar/hooks.ts
@@ -1,13 +1,19 @@
 import { format } from "date-fns";
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
 
+import type { IgnoredEvent, IgnoredRecurringSeries } from "@hypr/store";
 import { safeParseDate } from "@hypr/utils";
 import { TZDate } from "@hypr/utils";
 
+import { syncCalendarEvents } from "~/services/calendar";
+import { createCtx, syncCalendars } from "~/services/calendar/ctx";
+import { getSessionEvent } from "~/session/utils";
 import { useConfigValue } from "~/shared/config";
-import { useIgnoredEvents } from "~/store/tinybase/hooks";
 import * as main from "~/store/tinybase/store/main";
+import type { Store } from "~/store/tinybase/store/main";
 
+// Storage boundary for calendar/event reads and writes consumed by UI.
+// Keep return values plain TS objects so backend swaps stay transparent.
 export function useTimezone() {
   return useConfigValue("timezone") || undefined;
 }
@@ -52,14 +58,14 @@ export function useWeekStartsOn(): 0 | 1 {
 
 export type Calendar = {
   id: string;
-  tracking_id_calendar: string;
+  trackingIdCalendar: string;
   name: string;
   enabled: boolean;
   provider: string;
   source: string;
   color: string;
-  connection_id: string;
-  created_at: string;
+  connectionId: string;
+  createdAt: string;
 };
 
 export function useCalendar(id: string | null | undefined): Calendar | null {
@@ -69,14 +75,14 @@ export function useCalendar(id: string | null | undefined): Calendar | null {
     if (!row || Object.keys(row).length === 0) return null;
     return {
       id,
-      tracking_id_calendar: row.tracking_id_calendar ?? "",
+      trackingIdCalendar: row.tracking_id_calendar ?? "",
       name: row.name ?? "",
       enabled: row.enabled ?? false,
       provider: row.provider ?? "",
       source: row.source ?? "",
       color: row.color ?? "",
-      connection_id: row.connection_id ?? "",
-      created_at: row.created_at ?? "",
+      connectionId: row.connection_id ?? "",
+      createdAt: row.created_at ?? "",
     };
   }, [id, row]);
 }
@@ -97,6 +103,337 @@ export function useEnabledCalendars(): EnabledCalendar[] {
   }, [resultTable]);
 }
 
+export const ENABLED_CALENDARS_QUERY = main.QUERIES.enabledCalendars;
+
+export function useSyncCalendarEvents(): () => Promise<void> {
+  const store = main.UI.useStore(main.STORE_ID);
+  const enabledCalendars = main.UI.useResultTable(
+    main.QUERIES.enabledCalendars,
+    main.STORE_ID,
+  );
+  const enabledCalendarIds = useMemo(
+    () => Object.keys(enabledCalendars ?? {}),
+    [enabledCalendars],
+  );
+
+  return useCallback(async () => {
+    if (!store) {
+      return;
+    }
+
+    await syncCalendarEvents({
+      syncCalendars: (providerConnections) =>
+        syncCalendars(store as Store, providerConnections),
+      createCtx: (provider, connectionId) =>
+        createCtx(
+          {
+            store: store as Store,
+            enabledCalendarIds,
+          },
+          provider,
+          connectionId,
+        ),
+    });
+  }, [enabledCalendarIds, store]);
+}
+
+export function useCalendarsByProvider(provider: string): Calendar[] {
+  const table = main.UI.useTable("calendars", main.STORE_ID);
+  return useMemo(() => {
+    const out: Calendar[] = [];
+    for (const [id, row] of Object.entries(table)) {
+      if (row.provider !== provider) continue;
+      out.push({
+        id,
+        trackingIdCalendar: (row.tracking_id_calendar as string) ?? "",
+        name: (row.name as string) ?? "",
+        enabled: (row.enabled as boolean) ?? false,
+        provider: (row.provider as string) ?? "",
+        source: (row.source as string) ?? "",
+        color: (row.color as string) ?? "",
+        connectionId: (row.connection_id as string) ?? "",
+        createdAt: (row.created_at as string) ?? "",
+      });
+    }
+    return out;
+  }, [table, provider]);
+}
+
+export function useSetCalendarEnabled(): (
+  calendarId: string,
+  enabled: boolean,
+) => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (calendarId, enabled) => {
+      if (!store) return;
+      store.setPartialRow("calendars", calendarId, { enabled });
+    },
+    [store],
+  );
+}
+
+export type EventDetails = {
+  title: string | undefined;
+  startedAt: string | undefined;
+  endedAt: string | undefined;
+  location: string | undefined;
+  meetingLink: string | undefined;
+  description: string | undefined;
+  calendarId: string | undefined;
+};
+
+export function useEvent(eventId: string | undefined): EventDetails | null {
+  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 {
+    return JSON.parse(raw) as IgnoredEvent[];
+  } catch {
+    return [];
+  }
+}
+
+function parseIgnoredSeries(raw: string | undefined): IgnoredRecurringSeries[] {
+  if (!raw) return [];
+  try {
+    return JSON.parse(raw) as IgnoredRecurringSeries[];
+  } catch {
+    return [];
+  }
+}
+
+export function useIgnoredEvents() {
+  const store = main.UI.useStore(main.STORE_ID);
+
+  const ignoredEventsRaw = main.UI.useValue("ignored_events", main.STORE_ID) as
+    | string
+    | undefined;
+  const ignoredSeriesRaw = main.UI.useValue(
+    "ignored_recurring_series",
+    main.STORE_ID,
+  ) as string | undefined;
+
+  const ignoredIds = useMemo(() => {
+    const list = parseIgnoredEvents(ignoredEventsRaw);
+    return new Set(list.map((e) => e.tracking_id));
+  }, [ignoredEventsRaw]);
+
+  const ignoredSeriesIds = useMemo(() => {
+    const list = parseIgnoredSeries(ignoredSeriesRaw);
+    return new Set(list.map((e) => e.id));
+  }, [ignoredSeriesRaw]);
+
+  const isIgnored = useCallback(
+    (
+      trackingId: string | null | undefined,
+      recurrenceSeriesId: string | null | undefined,
+    ) => {
+      if (!trackingId) return false;
+      if (ignoredIds.has(trackingId)) return true;
+      if (recurrenceSeriesId && ignoredSeriesIds.has(recurrenceSeriesId))
+        return true;
+      return false;
+    },
+    [ignoredIds, ignoredSeriesIds],
+  );
+
+  const ignoreEvent = useCallback(
+    (trackingId: string) => {
+      if (!store) return;
+      const list = parseIgnoredEvents(
+        store.getValue("ignored_events") as string | undefined,
+      );
+      const now = new Date().toISOString();
+      list.push({
+        tracking_id: trackingId,
+        last_seen: now,
+      });
+      store.setValue("ignored_events", JSON.stringify(list));
+    },
+    [store],
+  );
+
+  const unignoreEvent = useCallback(
+    (trackingId: string) => {
+      if (!store) return;
+      const list = parseIgnoredEvents(
+        store.getValue("ignored_events") as string | undefined,
+      );
+      const filtered = list.filter((e) => e.tracking_id !== trackingId);
+      store.setValue("ignored_events", JSON.stringify(filtered));
+    },
+    [store],
+  );
+
+  const ignoreSeries = useCallback(
+    (seriesId: string) => {
+      if (!store) return;
+      const list = parseIgnoredSeries(
+        store.getValue("ignored_recurring_series") as string | undefined,
+      );
+      if (!list.some((e) => e.id === seriesId)) {
+        list.push({ id: seriesId, last_seen: new Date().toISOString() });
+        store.setValue("ignored_recurring_series", JSON.stringify(list));
+      }
+    },
+    [store],
+  );
+
+  const unignoreSeries = useCallback(
+    (seriesId: string) => {
+      if (!store) return;
+      const list = parseIgnoredSeries(
+        store.getValue("ignored_recurring_series") as string | undefined,
+      );
+      store.setValue(
+        "ignored_recurring_series",
+        JSON.stringify(list.filter((e) => e.id !== seriesId)),
+      );
+    },
+    [store],
+  );
+
+  return {
+    isIgnored,
+    ignoreEvent,
+    unignoreEvent,
+    ignoreSeries,
+    unignoreSeries,
+  };
+}
+
+export type TimelineEvent = {
+  id: string;
+  title: string;
+  startedAt: string;
+  endedAt: string;
+  calendarId: string;
+  trackingIdEvent: string;
+  hasRecurrenceRules: boolean;
+  recurrenceSeriesId: string;
+  isAllDay: boolean;
+};
+
+export function useTimelineEvent(eventId: string): TimelineEvent | null {
+  const row = main.UI.useResultRow(
+    main.QUERIES.timelineEvents,
+    eventId,
+    main.STORE_ID,
+  );
+  return useMemo(() => {
+    if (!row || Object.keys(row).length === 0) return null;
+    return {
+      id: eventId,
+      title: (row.title as string) ?? "",
+      startedAt: (row.started_at as string) ?? "",
+      endedAt: (row.ended_at as string) ?? "",
+      calendarId: (row.calendar_id as string) ?? "",
+      trackingIdEvent: (row.tracking_id_event as string) ?? "",
+      hasRecurrenceRules: (row.has_recurrence_rules as boolean) ?? false,
+      recurrenceSeriesId: (row.recurrence_series_id as string) ?? "",
+      isAllDay: (row.is_all_day as boolean) ?? false,
+    };
+  }, [eventId, row]);
+}
+
+export type TimelineSession = {
+  id: string;
+  title: string;
+  createdAt: string;
+  event: ReturnType<typeof getSessionEvent>;
+  folderId: string;
+};
+
+export function useTimelineSession(sessionId: string): TimelineSession | null {
+  const row = main.UI.useResultRow(
+    main.QUERIES.timelineSessions,
+    sessionId,
+    main.STORE_ID,
+  );
+  return useMemo(() => {
+    if (!row || Object.keys(row).length === 0) return null;
+    return {
+      id: sessionId,
+      title: (row.title as string) ?? "",
+      createdAt: (row.created_at as string) ?? "",
+      event: getSessionEvent({
+        event_json:
+          typeof row.event_json === "string" ? row.event_json : undefined,
+      }),
+      folderId: (row.folder_id as string) ?? "",
+    };
+  }, [sessionId, row]);
+}
+
 export type CalendarData = {
   eventIdsByDate: Record<string, string[]>;
   sessionIdsByDate: Record<string, string[]>;
diff --git a/apps/desktop/src/chat/components/chat-panel.tsx b/apps/desktop/src/chat/components/chat-panel.tsx
index 055edcf2fc..416c57d158 100644
--- a/apps/desktop/src/chat/components/chat-panel.tsx
+++ b/apps/desktop/src/chat/components/chat-panel.tsx
@@ -9,9 +9,9 @@ import { ChatSession } from "./session-provider";
 import { useSessionTab } from "./use-session-tab";
 
 import { useLanguageModel } from "~/ai/hooks";
-import { useChatActions } from "~/chat/store/use-chat-actions";
+import { useChatActions } from "~/chat/hooks/use-chat-actions";
 import { useShell } from "~/contexts/shell";
-import * as main from "~/store/tinybase/store/main";
+import { useCurrentUserId } from "~/session/hooks/globals";
 
 export function ChatView() {
   const { chat } = useShell();
@@ -20,7 +20,7 @@ export function ChatView() {
   const { currentSessionId } = useSessionTab();
 
   const model = useLanguageModel("chat");
-  const { user_id } = main.UI.useValues(main.STORE_ID);
+  const userId = useCurrentUserId();
 
   const handleGroupCreated = useCallback(
     (newGroupId: string) => {
@@ -47,7 +47,7 @@ export function ChatView() {
         onSelectChat={selectChat}
         handleClose={() => chat.sendEvent({ type: "CLOSE" })}
       />
-      {user_id && (
+      {userId && (
         <ChatSession
           key={sessionId}
           sessionId={sessionId}
diff --git a/apps/desktop/src/chat/components/header.tsx b/apps/desktop/src/chat/components/header.tsx
index bb3c01a69f..261ed23f62 100644
--- a/apps/desktop/src/chat/components/header.tsx
+++ b/apps/desktop/src/chat/components/header.tsx
@@ -24,8 +24,12 @@ import {
 } from "@hypr/ui/components/ui/tooltip";
 import { cn, formatDistanceToNow } from "@hypr/utils";
 
+import {
+  useChatGroup,
+  useChatGroupTitle,
+  useRecentChatGroupIds,
+} from "~/chat/hooks/chat-groups";
 import { useShell } from "~/contexts/shell";
-import * as main from "~/store/tinybase/store/main";
 
 export function ChatHeader({
   currentChatGroupId,
@@ -144,20 +148,8 @@ function ChatGroups({
 }) {
   const [isDropdownOpen, setIsDropdownOpen] = useState(false);
 
-  const currentChatTitle = main.UI.useCell(
-    "chat_groups",
-    currentChatGroupId || "",
-    "title",
-    main.STORE_ID,
-  );
-  const recentChatGroupIds = main.UI.useSortedRowIds(
-    "chat_groups",
-    "created_at",
-    true,
-    0,
-    5,
-    main.STORE_ID,
-  );
+  const currentChatTitle = useChatGroupTitle(currentChatGroupId);
+  const recentChatGroupIds = useRecentChatGroupIds(5);
 
   return (
     <DropdownMenu open={isDropdownOpen} onOpenChange={setIsDropdownOpen}>
@@ -234,7 +226,7 @@ function ChatGroupItem({
   isActive: boolean;
   onSelect: (groupId: string) => void;
 }) {
-  const chatGroup = main.UI.useRow("chat_groups", groupId, main.STORE_ID);
+  const chatGroup = useChatGroup(groupId);
 
   if (!chatGroup) {
     return null;
diff --git a/apps/desktop/src/chat/components/input/hooks.ts b/apps/desktop/src/chat/components/input/hooks.ts
index c03be742e7..805d12c8d5 100644
--- a/apps/desktop/src/chat/components/input/hooks.ts
+++ b/apps/desktop/src/chat/components/input/hooks.ts
@@ -1,13 +1,12 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 
 import { commands as analyticsCommands } from "@hypr/plugin-analytics";
 
 import type { ContextRef } from "~/chat/context/entities";
 import type { ChatEditorHandle, JSONContent } from "~/editor/chat";
 import { EMPTY_DOC } from "~/editor/markdown";
-import type { MentionConfig } from "~/editor/widgets";
-import { useSearchEngine } from "~/search/contexts/engine";
-import * as main from "~/store/tinybase/store/main";
+
+export { useMentionConfig } from "~/chat/hooks/mention-config";
 
 const draftsByKey = new Map<string, JSONContent>();
 
@@ -129,69 +128,6 @@ export function useAutoFocusEditor({
   }, [editorRef, disabled, shouldFocus]);
 }
 
-export function useMentionConfig(): MentionConfig {
-  const sessions = main.UI.useResultTable(
-    main.QUERIES.timelineSessions,
-    main.STORE_ID,
-  );
-  const humans = main.UI.useResultTable(
-    main.QUERIES.visibleHumans,
-    main.STORE_ID,
-  );
-  const organizations = main.UI.useResultTable(
-    main.QUERIES.visibleOrganizations,
-    main.STORE_ID,
-  );
-  const { search } = useSearchEngine();
-
-  return useMemo(
-    () => ({
-      trigger: "@",
-      handleSearch: async (query: string) => {
-        const results: {
-          id: string;
-          type: string;
-          label: string;
-          content?: string;
-        }[] = [];
-
-        if (query.trim()) {
-          const searchResults = await search(query);
-          for (const hit of searchResults) {
-            results.push({
-              id: hit.document.id,
-              type: hit.document.type,
-              label: hit.document.title,
-            });
-          }
-        } else {
-          Object.entries(sessions).forEach(([rowId, row]) => {
-            const title = row.title as string | undefined;
-            if (title) {
-              results.push({ id: rowId, type: "session", label: title });
-            }
-          });
-          Object.entries(humans).forEach(([rowId, row]) => {
-            const name = row.name as string | undefined;
-            if (name) {
-              results.push({ id: rowId, type: "human", label: name });
-            }
-          });
-          Object.entries(organizations).forEach(([rowId, row]) => {
-            const name = row.name as string | undefined;
-            if (name) {
-              results.push({ id: rowId, type: "organization", label: name });
-            }
-          });
-        }
-
-        return results.slice(0, 5);
-      },
-    }),
-    [sessions, humans, organizations, search],
-  );
-}
-
 function tiptapJsonToText(json: any): string {
   if (!json || typeof json !== "object") {
     return "";
diff --git a/apps/desktop/src/chat/components/message/tool/search.tsx b/apps/desktop/src/chat/components/message/tool/search.tsx
index 8bd30bed8e..b6dfd18c15 100644
--- a/apps/desktop/src/chat/components/message/tool/search.tsx
+++ b/apps/desktop/src/chat/components/message/tool/search.tsx
@@ -14,7 +14,6 @@ import { useToolState } from "./shared";
 
 import { Disclosure } from "~/chat/components/message/shared";
 import { ToolRenderer } from "~/chat/components/message/types";
-import * as main from "~/store/tinybase/store/main";
 import { useTabs } from "~/store/zustand/tabs";
 
 type Renderer = ToolRenderer<"tool-search_sessions">;
@@ -222,7 +221,6 @@ function RenderContent({ part }: { part: Part }) {
 
 function RenderSession({ result }: { result: SearchResult }) {
   const { id: sessionId } = result;
-  const session = main.UI.useRow("sessions", sessionId, main.STORE_ID);
   const openNew = useTabs((state) => state.openNew);
 
   const handleClick = useCallback(() => {
@@ -234,14 +232,6 @@ function RenderSession({ result }: { result: SearchResult }) {
     return new Date(result.created_at).toLocaleString();
   }, [result.created_at]);
 
-  if (!session) {
-    return (
-      <div className="text-muted-foreground text-xs italic">
-        Session unavailable
-      </div>
-    );
-  }
-
   return (
     <button
       type="button"
diff --git a/apps/desktop/src/chat/components/session-provider.tsx b/apps/desktop/src/chat/components/session-provider.tsx
index b12fa34ede..f40f55f3f8 100644
--- a/apps/desktop/src/chat/components/session-provider.tsx
+++ b/apps/desktop/src/chat/components/session-provider.tsx
@@ -15,14 +15,14 @@ import {
   useChatContextPipeline,
 } from "~/chat/context/use-chat-context-pipeline";
 import {
-  buildPersistedChatMessageRow,
-  getPersistedChatMessages,
-  getVisibleChatMessages,
-} from "~/chat/store/persisted-messages";
+  useDeleteLatestAssistantMessage,
+  useGetVisibleChatMessages,
+  useSetChatMessage,
+  useSyncChatMessages,
+} from "~/chat/hooks/chat-messages";
 import { stripEphemeralToolContext } from "~/chat/tools/strip-ephemeral-tool-context";
 import { useTransport } from "~/chat/transport/use-transport";
 import type { HyprUIMessage } from "~/chat/types";
-import * as main from "~/store/tinybase/store/main";
 
 interface ChatSessionProps {
   sessionId: string;
@@ -60,8 +60,10 @@ export function ChatSession({
   systemPromptOverride,
   children,
 }: ChatSessionProps) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const { user_id } = main.UI.useValues(main.STORE_ID);
+  const getVisibleChatMessages = useGetVisibleChatMessages();
+  const setChatMessage = useSetChatMessage();
+  const deleteLatestAssistantMessage = useDeleteLatestAssistantMessage();
+  const syncChatMessages = useSyncChatMessages();
 
   const [pendingManualRefs, setPendingManualRefs] = useState<ContextRef[]>([]);
   const [pendingDraftRefs, setPendingDraftRefs] = useState<ContextRef[]>([]);
@@ -90,7 +92,6 @@ export function ChatSession({
     modelOverride,
     extraTools,
     systemPromptOverride,
-    store,
   );
 
   const {
@@ -103,27 +104,20 @@ export function ChatSession({
     setMessages: chatSetMessages,
   } = useChat<HyprUIMessage>({
     id: sessionId,
-    messages:
-      store && chatGroupId ? getVisibleChatMessages(store, chatGroupId) : [],
+    messages: chatGroupId ? getVisibleChatMessages(chatGroupId) : [],
     transport: transport ?? undefined,
     onFinish: ({ message, isAbort }) => {
-      if (isAbort || !chatGroupId || !store || !user_id) return;
+      if (isAbort || !chatGroupId) return;
       const sanitizedParts = stripEphemeralToolContext(message.parts);
       const sanitizedMessage =
         sanitizedParts === message.parts
           ? message
           : { ...message, parts: sanitizedParts };
-      store.setRow(
-        "chat_messages",
-        sanitizedMessage.id,
-        buildPersistedChatMessageRow({
-          message: sanitizedMessage,
-          chatGroupId,
-          userId: user_id,
-          status: "ready",
-          existingRow: store.getRow("chat_messages", sanitizedMessage.id),
-        }),
-      );
+      setChatMessage({
+        message: sanitizedMessage,
+        chatGroupId,
+        status: "ready",
+      });
     },
   });
 
@@ -137,27 +131,20 @@ export function ChatSession({
   );
 
   const regenerate = useCallback(() => {
-    if (!store || !chatGroupId) return;
-    const last = [...getPersistedChatMessages(store, chatGroupId)]
-      .reverse()
-      .find((m) => m.message.role === "assistant");
-    if (last) store.delRow("chat_messages", last.id);
+    if (!chatGroupId) return;
+    deleteLatestAssistantMessage(chatGroupId);
     void chatRegenerate();
-  }, [store, chatGroupId, chatRegenerate]);
+  }, [chatGroupId, chatRegenerate, deleteLatestAssistantMessage]);
 
   const setMessages = useCallback(
     (next: HyprUIMessage[] | ((prev: HyprUIMessage[]) => HyprUIMessage[])) => {
       chatSetMessages(next);
-      if (!store || !chatGroupId) return;
+      if (!chatGroupId) return;
       const resolved = typeof next === "function" ? next(messages) : next;
       const nextIds = new Set(resolved.map((m) => m.id));
-      store.transaction(() => {
-        getPersistedChatMessages(store, chatGroupId).forEach(({ id }) => {
-          if (!nextIds.has(id)) store.delRow("chat_messages", id);
-        });
-      });
+      syncChatMessages(chatGroupId, nextIds);
     },
-    [chatGroupId, messages, chatSetMessages, store],
+    [chatGroupId, messages, chatSetMessages, syncChatMessages],
   );
 
   const prevUserMsgCountRef = useRef(0);
@@ -179,7 +166,6 @@ export function ChatSession({
     messages,
     currentSessionId,
     pendingManualRefs: pendingMessageRefs,
-    store,
   });
 
   return (
diff --git a/apps/desktop/src/chat/context/session-context-hydrator.ts b/apps/desktop/src/chat/context/session-context-hydrator.ts
index 52c9f1d52f..692e8e8cca 100644
--- a/apps/desktop/src/chat/context/session-context-hydrator.ts
+++ b/apps/desktop/src/chat/context/session-context-hydrator.ts
@@ -2,7 +2,7 @@ import { commands as fsSyncCommands } from "@hypr/plugin-fs-sync";
 import type { SessionContentData } from "@hypr/plugin-fs-sync";
 import type { SessionContext, Transcript } from "@hypr/plugin-template";
 
-import type * as main from "~/store/tinybase/store/main";
+import type { Store as MainStore } from "~/store/tinybase/store/main";
 import {
   buildRenderTranscriptRequestFromFsTranscript,
   renderTranscriptSegments,
@@ -26,7 +26,7 @@ function extractEventName(event: unknown): string | null {
 
 async function buildTranscript(
   transcriptData: SessionContentData["transcript"],
-  store: ReturnType<typeof main.UI.useStore>,
+  store: MainStore | undefined,
   sessionId: string,
 ): Promise<Transcript | null> {
   const transcripts = transcriptData?.transcripts ?? [];
@@ -63,7 +63,7 @@ async function buildTranscript(
 }
 
 export async function hydrateSessionContextFromFs(
-  store: ReturnType<typeof main.UI.useStore>,
+  store: MainStore | undefined,
   sessionId: string,
 ): Promise<SessionContext | null> {
   const result = await fsSyncCommands.loadSessionContent(sessionId);
diff --git a/apps/desktop/src/chat/context/use-chat-context-pipeline.ts b/apps/desktop/src/chat/context/use-chat-context-pipeline.ts
index e57f577679..efdc4aaead 100644
--- a/apps/desktop/src/chat/context/use-chat-context-pipeline.ts
+++ b/apps/desktop/src/chat/context/use-chat-context-pipeline.ts
@@ -3,107 +3,18 @@ import { useMemo } from "react";
 import {
   type ContextEntity,
   type ContextRef,
-  extractToolContextEntities,
   dedupeByKey,
+  extractToolContextEntities,
 } from "./entities";
 import { extractContextRefsFromMessages } from "./refs";
 
 import type { HyprUIMessage } from "~/chat/types";
-import type * as main from "~/store/tinybase/store/main";
-
-function getSessionDisplayData(
-  store: ReturnType<typeof main.UI.useStore>,
-  sessionId: string,
-): { title: string | null; date: string | null } {
-  if (!store) {
-    return { title: null, date: null };
-  }
-  const row = store.getRow("sessions", sessionId);
-  return {
-    title: typeof row.title === "string" && row.title.trim() ? row.title : null,
-    date:
-      typeof row.created_at === "string" && row.created_at.trim()
-        ? row.created_at
-        : null,
-  };
-}
-
-function getHumanDisplayData(
-  store: ReturnType<typeof main.UI.useStore>,
-  humanId: string,
-): {
-  name: string | null;
-  email: string | null;
-  organizationName: string | null;
-} {
-  if (!store) {
-    return { name: null, email: null, organizationName: null };
-  }
-
-  const row = store.getRow("humans", humanId);
-  const orgId = typeof row.org_id === "string" ? row.org_id : null;
-  const organization =
-    orgId && store.hasRow("organizations", orgId)
-      ? store.getRow("organizations", orgId)
-      : {};
-
-  return {
-    name: typeof row.name === "string" && row.name.trim() ? row.name : null,
-    email: typeof row.email === "string" && row.email.trim() ? row.email : null,
-    organizationName:
-      typeof organization.name === "string" && organization.name.trim()
-        ? organization.name
-        : null,
-  };
-}
-
-function getOrganizationDisplayData(
-  store: ReturnType<typeof main.UI.useStore>,
-  organizationId: string,
-): { name: string | null } {
-  if (!store) {
-    return { name: null };
-  }
-
-  const row = store.getRow("organizations", organizationId);
-  return {
-    name: typeof row.name === "string" && row.name.trim() ? row.name : null,
-  };
-}
-
-function toDisplayEntity(
-  ref: ContextRef,
-  store: ReturnType<typeof main.UI.useStore>,
-  removable: boolean,
-): ContextEntity {
-  if (ref.kind === "session") {
-    return {
-      ...ref,
-      ...getSessionDisplayData(store, ref.sessionId),
-      removable,
-    };
-  }
-
-  if (ref.kind === "human") {
-    return {
-      ...ref,
-      ...getHumanDisplayData(store, ref.humanId),
-      removable,
-    };
-  }
-
-  return {
-    ...ref,
-    ...getOrganizationDisplayData(store, ref.organizationId),
-    removable,
-  };
-}
+import { useDisplayEntityRenderer } from "~/session/hooks/runtime";
 
 type UseChatContextPipelineParams = {
   messages: HyprUIMessage[];
   currentSessionId?: string;
   pendingManualRefs: ContextRef[];
-  store: ReturnType<typeof main.UI.useStore>;
 };
 
 export type DisplayEntity = ContextEntity & { pending: boolean };
@@ -112,11 +23,12 @@ export function useChatContextPipeline({
   messages,
   currentSessionId,
   pendingManualRefs,
-  store,
 }: UseChatContextPipelineParams): {
   contextEntities: DisplayEntity[];
   pendingRefs: ContextRef[];
 } {
+  const toDisplayEntity = useDisplayEntityRenderer();
+
   const committedRefs = useMemo(
     () => extractContextRefsFromMessages(messages),
     [messages],
@@ -143,17 +55,15 @@ export function useChatContextPipeline({
   }, [currentSessionId, pendingManualRefs]);
 
   const committedEntities = useMemo(
-    () => committedRefs.map((ref) => toDisplayEntity(ref, store, false)),
-    [committedRefs, store],
+    () => committedRefs.map((ref) => toDisplayEntity(ref, false)),
+    [committedRefs, toDisplayEntity],
   );
 
   // Pending manual refs are removable; pending auto-current is not.
   const pendingEntities = useMemo(
     () =>
-      pendingRefs.map((ref) =>
-        toDisplayEntity(ref, store, ref.source === "manual"),
-      ),
-    [pendingRefs, store],
+      pendingRefs.map((ref) => toDisplayEntity(ref, ref.source === "manual")),
+    [pendingRefs, toDisplayEntity],
   );
 
   const rawEntities = useMemo(
diff --git a/apps/desktop/src/chat/hooks/chat-groups.ts b/apps/desktop/src/chat/hooks/chat-groups.ts
new file mode 100644
index 0000000000..98fdd6d0b9
--- /dev/null
+++ b/apps/desktop/src/chat/hooks/chat-groups.ts
@@ -0,0 +1,43 @@
+import { useMemo } from "react";
+
+import * as main from "~/store/tinybase/store/main";
+
+// Storage boundary for chat-group selection metadata used by UI.
+export type ChatGroup = {
+  id: string;
+  title: string;
+  created_at: string;
+};
+
+export function useChatGroupTitle(groupId: string | undefined): string {
+  const title = main.UI.useCell(
+    "chat_groups",
+    groupId || "",
+    "title",
+    main.STORE_ID,
+  );
+  return (title as string | undefined) ?? "";
+}
+
+export function useChatGroup(groupId: string): ChatGroup | null {
+  const row = main.UI.useRow("chat_groups", groupId, main.STORE_ID);
+  return useMemo(() => {
+    if (!row || Object.keys(row).length === 0) return null;
+    return {
+      id: groupId,
+      title: String(row.title ?? ""),
+      created_at: String(row.created_at ?? ""),
+    };
+  }, [groupId, row]);
+}
+
+export function useRecentChatGroupIds(limit: number): string[] {
+  return main.UI.useSortedRowIds(
+    "chat_groups",
+    "created_at",
+    true,
+    0,
+    limit,
+    main.STORE_ID,
+  );
+}
diff --git a/apps/desktop/src/chat/hooks/chat-messages.ts b/apps/desktop/src/chat/hooks/chat-messages.ts
new file mode 100644
index 0000000000..4298c3c878
--- /dev/null
+++ b/apps/desktop/src/chat/hooks/chat-messages.ts
@@ -0,0 +1,81 @@
+import { useCallback } from "react";
+
+import type { ChatMessageStatus } from "@hypr/store";
+
+import {
+  buildPersistedChatMessageRow,
+  getPersistedChatMessages,
+  getVisibleChatMessages,
+} from "./persisted-messages";
+
+import type { HyprUIMessage } from "~/chat/types";
+import * as main from "~/store/tinybase/store/main";
+
+// Storage boundary for chat-message persistence/visibility behavior.
+// Consumers should depend on these hooks rather than storage internals.
+export function useGetVisibleChatMessages() {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (chatGroupId: string): HyprUIMessage[] => {
+      if (!store) return [];
+      return getVisibleChatMessages(store, chatGroupId);
+    },
+    [store],
+  );
+}
+
+export function useSetChatMessage() {
+  const store = main.UI.useStore(main.STORE_ID);
+  const { user_id: userId } = main.UI.useValues(main.STORE_ID);
+  return useCallback(
+    (params: {
+      message: HyprUIMessage;
+      chatGroupId: string;
+      status: ChatMessageStatus;
+    }) => {
+      if (!store || !userId) return;
+      const existingRow = store.getRow("chat_messages", params.message.id);
+      store.setRow(
+        "chat_messages",
+        params.message.id,
+        buildPersistedChatMessageRow({
+          message: params.message,
+          chatGroupId: params.chatGroupId,
+          userId,
+          status: params.status,
+          existingRow,
+        }),
+      );
+    },
+    [store, userId],
+  );
+}
+
+export function useDeleteLatestAssistantMessage() {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (chatGroupId: string) => {
+      if (!store) return;
+      const last = [...getPersistedChatMessages(store, chatGroupId)]
+        .reverse()
+        .find((m) => m.message.role === "assistant");
+      if (last) store.delRow("chat_messages", last.id);
+    },
+    [store],
+  );
+}
+
+export function useSyncChatMessages() {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (chatGroupId: string, keepIds: Set<string>) => {
+      if (!store) return;
+      store.transaction(() => {
+        getPersistedChatMessages(store, chatGroupId).forEach(({ id }) => {
+          if (!keepIds.has(id)) store.delRow("chat_messages", id);
+        });
+      });
+    },
+    [store],
+  );
+}
diff --git a/apps/desktop/src/chat/hooks/mention-config.ts b/apps/desktop/src/chat/hooks/mention-config.ts
new file mode 100644
index 0000000000..fa77f35221
--- /dev/null
+++ b/apps/desktop/src/chat/hooks/mention-config.ts
@@ -0,0 +1,40 @@
+import { useMemo } from "react";
+
+import type { MentionConfig } from "~/editor/widgets";
+import { useSearchEngine } from "~/search/contexts/engine";
+import { useMentionableEntities } from "~/session/hooks/queries";
+
+export function useMentionConfig(): MentionConfig {
+  const entities = useMentionableEntities();
+  const { search } = useSearchEngine();
+
+  return useMemo(
+    () => ({
+      trigger: "@",
+      handleSearch: async (query: string) => {
+        const results: {
+          id: string;
+          type: string;
+          label: string;
+          content?: string;
+        }[] = [];
+
+        if (query.trim()) {
+          const searchResults = await search(query);
+          for (const hit of searchResults) {
+            results.push({
+              id: hit.document.id,
+              type: hit.document.type,
+              label: hit.document.title,
+            });
+          }
+        } else {
+          results.push(...entities);
+        }
+
+        return results.slice(0, 5);
+      },
+    }),
+    [entities, search],
+  );
+}
diff --git a/apps/desktop/src/chat/store/persisted-messages.test.ts b/apps/desktop/src/chat/hooks/persisted-messages.test.ts
similarity index 100%
rename from apps/desktop/src/chat/store/persisted-messages.test.ts
rename to apps/desktop/src/chat/hooks/persisted-messages.test.ts
diff --git a/apps/desktop/src/chat/store/persisted-messages.ts b/apps/desktop/src/chat/hooks/persisted-messages.ts
similarity index 100%
rename from apps/desktop/src/chat/store/persisted-messages.ts
rename to apps/desktop/src/chat/hooks/persisted-messages.ts
diff --git a/apps/desktop/src/chat/store/use-chat-actions.ts b/apps/desktop/src/chat/hooks/use-chat-actions.ts
similarity index 100%
rename from apps/desktop/src/chat/store/use-chat-actions.ts
rename to apps/desktop/src/chat/hooks/use-chat-actions.ts
diff --git a/apps/desktop/src/chat/store/useCreateChatMessage.ts b/apps/desktop/src/chat/hooks/useCreateChatMessage.ts
similarity index 100%
rename from apps/desktop/src/chat/store/useCreateChatMessage.ts
rename to apps/desktop/src/chat/hooks/useCreateChatMessage.ts
diff --git a/apps/desktop/src/chat/tools/edit-summary.ts b/apps/desktop/src/chat/tools/edit-summary.ts
index 7eabc4e77e..f6afa04e50 100644
--- a/apps/desktop/src/chat/tools/edit-summary.ts
+++ b/apps/desktop/src/chat/tools/edit-summary.ts
@@ -4,51 +4,14 @@ import { z } from "zod";
 import type { ToolDependencies } from "./types";
 
 import { usePendingEditStore } from "~/chat/tools/pending-edit-store";
-import { json2md, md2json, parseJsonContent } from "~/editor/markdown";
 import { id } from "~/shared/utils";
-import * as main from "~/store/tinybase/store/main";
-
-type Store = NonNullable<ReturnType<typeof main.UI.useStore>>;
-
-type SummaryCandidate = {
-  enhancedNoteId: string;
-  title: string;
-  templateId?: string;
-  position?: number;
-};
-
-function listSummaryCandidates(
-  store: Store,
-  noteIds: string[],
-): SummaryCandidate[] {
-  return noteIds.map((enhancedNoteId) => {
-    const title = store.getCell("enhanced_notes", enhancedNoteId, "title");
-    const templateId = store.getCell(
-      "enhanced_notes",
-      enhancedNoteId,
-      "template_id",
-    );
-    const position = store.getCell(
-      "enhanced_notes",
-      enhancedNoteId,
-      "position",
-    );
-
-    return {
-      enhancedNoteId,
-      title: typeof title === "string" && title.trim() ? title : "Summary",
-      templateId:
-        typeof templateId === "string" && templateId ? templateId : undefined,
-      position: typeof position === "number" ? position : undefined,
-    };
-  });
-}
 
 export const buildEditSummaryTool = (
   deps: Pick<
     ToolDependencies,
-    | "getStore"
-    | "getIndexes"
+    | "getSummaryCandidates"
+    | "getSummaryMarkdown"
+    | "applySummaryMarkdown"
     | "getSessionId"
     | "getEnhancedNoteId"
     | "openEditTab"
@@ -77,12 +40,10 @@ export const buildEditSummaryTool = (
       enhancedNoteId?: string;
       content: string;
     }) => {
-      const store = deps.getStore();
-      const indexes = deps.getIndexes();
       const activeSessionId = deps.getSessionId();
       const sessionId = params.sessionId ?? activeSessionId;
 
-      if (!store || !indexes || !sessionId) {
+      if (!sessionId) {
         return {
           status: "error",
           message:
@@ -90,10 +51,8 @@ export const buildEditSummaryTool = (
         };
       }
 
-      const noteIds = indexes.getSliceRowIds(
-        main.INDEXES.enhancedNotesBySession,
-        sessionId,
-      );
+      const candidates = deps.getSummaryCandidates(sessionId);
+      const noteIds = candidates.map((candidate) => candidate.enhancedNoteId);
 
       if (noteIds.length === 0) {
         return {
@@ -106,7 +65,6 @@ export const buildEditSummaryTool = (
 
       const requestedEnhancedNoteId = params.enhancedNoteId;
       const activeEnhancedNoteId = deps.getEnhancedNoteId();
-      const candidates = listSummaryCandidates(store, noteIds);
 
       if (requestedEnhancedNoteId && !noteIdSet.has(requestedEnhancedNoteId)) {
         return {
@@ -117,14 +75,8 @@ export const buildEditSummaryTool = (
       }
 
       const defaultEnhancedNoteId =
-        noteIds.find((id) => {
-          const templateId = store.getCell(
-            "enhanced_notes",
-            id,
-            "template_id",
-          ) as string | undefined;
-          return !templateId;
-        }) ?? null;
+        candidates.find((candidate) => !candidate.templateId)?.enhancedNoteId ??
+        null;
 
       const enhancedNoteId =
         (requestedEnhancedNoteId && noteIdSet.has(requestedEnhancedNoteId)
@@ -145,10 +97,7 @@ export const buildEditSummaryTool = (
         };
       }
 
-      const raw = store.getCell("enhanced_notes", enhancedNoteId, "content") as
-        | string
-        | undefined;
-      const currentContent = json2md(parseJsonContent(raw));
+      const currentContent = deps.getSummaryMarkdown(enhancedNoteId);
 
       const requestId = id();
       const approved = await new Promise<boolean>((resolve) => {
@@ -168,10 +117,7 @@ export const buildEditSummaryTool = (
       }
 
       try {
-        const json = md2json(params.content);
-        store.setPartialRow("enhanced_notes", enhancedNoteId, {
-          content: JSON.stringify(json),
-        });
+        deps.applySummaryMarkdown(enhancedNoteId, params.content);
       } catch {
         return {
           status: "error",
diff --git a/apps/desktop/src/chat/tools/search-sessions.ts b/apps/desktop/src/chat/tools/search-sessions.ts
index eb4614e637..c2507253cc 100644
--- a/apps/desktop/src/chat/tools/search-sessions.ts
+++ b/apps/desktop/src/chat/tools/search-sessions.ts
@@ -4,7 +4,6 @@ import { z } from "zod";
 import type { ToolDependencies } from "./types";
 
 import type { SearchFilters } from "~/search/contexts/engine/types";
-import { getSessionSearchTimestamp } from "~/search/contexts/engine/utils";
 
 const gteSchema = z
   .number()
@@ -130,7 +129,6 @@ Returns relevant sessions with their content.
       filters?: SearchSessionsFiltersInput;
       limit?: number;
     }) => {
-      const store = deps.getStore();
       const query = params.query ?? "";
       const createdAtFilter = params.filters?.created_at;
       const effectiveFilters: SearchFilters | null = createdAtFilter
@@ -152,16 +150,14 @@ Returns relevant sessions with their content.
       const sessionHits = hits.filter((hit) => hit.document.type === "session");
       const limit = params.limit ?? 5;
       const results = sessionHits.slice(0, limit).map((hit) => {
-        const sessionRow = store?.getRow("sessions", hit.document.id);
+        const createdAt = deps.getSessionSearchTimestamp(hit.document.id);
 
         return {
           id: hit.document.id,
           title: hit.document.title,
           excerpt: hit.document.content.slice(0, 180),
           score: hit.score,
-          created_at: sessionRow
-            ? getSessionSearchTimestamp(sessionRow)
-            : hit.document.created_at,
+          created_at: createdAt ?? hit.document.created_at,
         };
       });
 
diff --git a/apps/desktop/src/chat/tools/types.ts b/apps/desktop/src/chat/tools/types.ts
index ffd4025b30..b483243f13 100644
--- a/apps/desktop/src/chat/tools/types.ts
+++ b/apps/desktop/src/chat/tools/types.ts
@@ -1,8 +1,5 @@
 import type { SearchFilters, SearchHit } from "~/search/contexts/engine/types";
-import type * as main from "~/store/tinybase/store/main";
-
-type Store = NonNullable<ReturnType<typeof main.UI.useStore>>;
-type Indexes = NonNullable<ReturnType<typeof main.UI.useIndexes>>;
+import type { SummaryEditCandidate } from "~/session/hooks/enhanced-notes";
 
 export type ContactSearchResult = {
   id: string;
@@ -38,8 +35,10 @@ export interface ToolDependencies {
     query: string,
     limit: number,
   ) => Promise<CalendarEventSearchResult[]>;
-  getStore: () => Store | undefined;
-  getIndexes: () => Indexes | undefined;
+  getSessionSearchTimestamp: (sessionId: string) => number | undefined;
+  getSummaryCandidates: (sessionId: string) => SummaryEditCandidate[];
+  getSummaryMarkdown: (enhancedNoteId: string) => string;
+  applySummaryMarkdown: (enhancedNoteId: string, markdown: string) => void;
   getSessionId: () => string | undefined;
   getEnhancedNoteId: () => string | undefined;
   openEditTab: (requestId: string) => void;
diff --git a/apps/desktop/src/chat/transport/use-transport.ts b/apps/desktop/src/chat/transport/use-transport.ts
index 47a1d7a05b..67586121a7 100644
--- a/apps/desktop/src/chat/transport/use-transport.ts
+++ b/apps/desktop/src/chat/transport/use-transport.ts
@@ -4,85 +4,22 @@ import { useEffect, useMemo, useState } from "react";
 import { commands as templateCommands } from "@hypr/plugin-template";
 
 import { CustomChatTransport } from "./index";
-import type { ResolvedChatContext } from "./index";
 
 import { useLanguageModel } from "~/ai/hooks";
-import type { ContextRef } from "~/chat/context/entities";
-import { hydrateSessionContextFromFs } from "~/chat/context/session-context-hydrator";
 import { useToolRegistry } from "~/contexts/tool";
-import * as main from "~/store/tinybase/store/main";
-
-function renderHumanContext(
-  store: ReturnType<typeof main.UI.useStore>,
-  humanId: string,
-): string | null {
-  if (!store) {
-    return null;
-  }
-
-  const human = store.getRow("humans", humanId);
-  const orgId = typeof human.org_id === "string" ? human.org_id : "";
-  const organization =
-    orgId && store.hasRow("organizations", orgId)
-      ? store.getRow("organizations", orgId)
-      : {};
-
-  const name =
-    typeof human.name === "string" && human.name.trim() ? human.name : null;
-  const email =
-    typeof human.email === "string" && human.email.trim() ? human.email : null;
-  const jobTitle =
-    typeof human.job_title === "string" && human.job_title.trim()
-      ? human.job_title
-      : null;
-  const organizationName =
-    typeof organization.name === "string" && organization.name.trim()
-      ? organization.name
-      : null;
-  const memo =
-    typeof human.memo === "string" && human.memo.trim() ? human.memo : null;
-
-  if (!name && !email) {
-    return null;
-  }
-
-  const details = [
-    jobTitle,
-    organizationName ? `Organization: ${organizationName}` : null,
-    email ? `Email: ${email}` : null,
-    memo ? `Notes: ${memo}` : null,
-  ].filter(Boolean);
-
-  return [`Referenced contact: ${name ?? email}`, ...details].join("\n");
-}
-
-function renderOrganizationContext(
-  store: ReturnType<typeof main.UI.useStore>,
-  organizationId: string,
-): string | null {
-  if (!store) {
-    return null;
-  }
-
-  const organization = store.getRow("organizations", organizationId);
-  const name =
-    typeof organization.name === "string" && organization.name.trim()
-      ? organization.name
-      : null;
-
-  return name ? `Referenced organization: ${name}` : null;
-}
+import { useAiLanguage } from "~/session/hooks/globals";
+import { useResolveContextRef } from "~/session/hooks/runtime";
 
 export function useTransport(
   modelOverride?: LanguageModel,
   extraTools?: ToolSet,
   systemPromptOverride?: string,
-  store?: ReturnType<typeof main.UI.useStore>,
 ) {
   const registry = useToolRegistry();
   const configuredModel = useLanguageModel("chat");
   const model = modelOverride ?? configuredModel;
-  const language = main.UI.useValue("ai_language", main.STORE_ID) ?? "en";
+  const language = useAiLanguage();
+  const resolveContextRef = useResolveContextRef();
   const [systemPrompt, setSystemPrompt] = useState<string | undefined>();
 
   useEffect(() => {
@@ -154,34 +91,9 @@ export function useTransport(
       model,
       tools,
       effectiveSystemPrompt,
-      async (ref: ContextRef) => {
-        if (!store) {
-          return null;
-        }
-        if (ref.kind === "session") {
-          const context = await hydrateSessionContextFromFs(
-            store,
-            ref.sessionId,
-          );
-          return context
-            ? ({ kind: "session", context } satisfies ResolvedChatContext)
-            : null;
-        }
-
-        if (ref.kind === "human") {
-          const text = renderHumanContext(store, ref.humanId);
-          return text
-            ? ({ kind: "text", text } satisfies ResolvedChatContext)
-            : null;
-        }
-
-        const text = renderOrganizationContext(store, ref.organizationId);
-        return text
-          ? ({ kind: "text", text } satisfies ResolvedChatContext)
-          : null;
-      },
+      resolveContextRef,
     );
-  }, [model, tools, effectiveSystemPrompt, store]);
+  }, [model, tools, effectiveSystemPrompt, resolveContextRef]);
 
   return {
     transport,
diff --git a/apps/desktop/src/chat_shortcuts/details.tsx b/apps/desktop/src/chat_shortcuts/details.tsx
index ba25e11b1f..f13c565903 100644
--- a/apps/desktop/src/chat_shortcuts/details.tsx
+++ b/apps/desktop/src/chat_shortcuts/details.tsx
@@ -4,12 +4,16 @@ import { Button } from "@hypr/ui/components/ui/button";
 import { Input } from "@hypr/ui/components/ui/input";
 import { Textarea } from "@hypr/ui/components/ui/textarea";
 
+import {
+  useChatShortcutCell,
+  useDeleteChatShortcut,
+  useUpdateChatShortcut,
+} from "~/chat_shortcuts/hooks";
 import {
   DangerZone,
   ResourceDetailEmpty,
   ResourcePreviewHeader,
 } from "~/shared/ui/resource-list";
-import * as main from "~/store/tinybase/store/main";
 
 type WebShortcut = {
   slug: string;
@@ -96,34 +100,18 @@ function ChatShortcutForm({
   id: string;
   setSelectedMineId: (id: string | null) => void;
 }) {
-  const title = main.UI.useCell("chat_shortcuts", id, "title", main.STORE_ID);
-  const content = main.UI.useCell(
-    "chat_shortcuts",
-    id,
-    "content",
-    main.STORE_ID,
-  );
-  const [localTitle, setLocalTitle] = useState(title || "");
-  const [localContent, setLocalContent] = useState(content || "");
+  const title = useChatShortcutCell(id, "title");
+  const content = useChatShortcutCell(id, "content");
+  const [localTitle, setLocalTitle] = useState(title);
+  const [localContent, setLocalContent] = useState(content);
 
   useEffect(() => {
-    setLocalTitle(title || "");
-    setLocalContent(content || "");
+    setLocalTitle(title);
+    setLocalContent(content);
   }, [title, content, id]);
 
-  const handleUpdate = main.UI.useSetPartialRowCallback(
-    "chat_shortcuts",
-    id,
-    (row: { title?: string; content?: string }) => row,
-    [id],
-    main.STORE_ID,
-  );
-
-  const handleDelete = main.UI.useDelRowCallback(
-    "chat_shortcuts",
-    () => id,
-    main.STORE_ID,
-  );
+  const handleUpdate = useUpdateChatShortcut(id);
+  const handleDelete = useDeleteChatShortcut(id);
 
   const handleSave = useCallback(() => {
     handleUpdate({ title: localTitle, content: localContent });
diff --git a/apps/desktop/src/chat_shortcuts/hooks.test.tsx b/apps/desktop/src/chat_shortcuts/hooks.test.tsx
new file mode 100644
index 0000000000..464086b609
--- /dev/null
+++ b/apps/desktop/src/chat_shortcuts/hooks.test.tsx
@@ -0,0 +1,76 @@
+import { renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { useValuesMock, useCellMock, useSetRowCallbackMock } = vi.hoisted(
+  () => ({
+    useValuesMock: vi.fn<() => { user_id: string | undefined }>(() => ({
+      user_id: undefined,
+    })),
+    useCellMock: vi.fn(() => undefined),
+    useSetRowCallbackMock: vi.fn(() => vi.fn()),
+  }),
+);
+
+vi.mock("~/store/tinybase/store/main", () => ({
+  STORE_ID: "main",
+  QUERIES: {
+    visibleChatShortcuts: "visibleChatShortcuts",
+  },
+  UI: {
+    useResultTable: vi.fn(() => ({})),
+    useCell: useCellMock,
+    useValues: useValuesMock,
+    useSetRowCallback: useSetRowCallbackMock,
+    useSetPartialRowCallback: vi.fn(() => vi.fn()),
+    useDelRowCallback: vi.fn(() => vi.fn()),
+  },
+}));
+
+import { useChatShortcutCell, useCreateChatShortcut } from "./hooks";
+
+describe("chat shortcuts boundary hooks", () => {
+  beforeEach(() => {
+    useValuesMock.mockReset();
+    useCellMock.mockReset();
+    useSetRowCallbackMock.mockReset();
+  });
+
+  it("normalizes missing shortcut cells to empty string", () => {
+    useCellMock.mockReturnValue(undefined);
+    const result = renderHook(() => useChatShortcutCell("shortcut-1", "title"));
+    expect(result.result.current).toBe("");
+  });
+
+  it("returns null when creating shortcut without user id", () => {
+    useValuesMock.mockReturnValue({ user_id: undefined });
+    const setRow = vi.fn();
+    useSetRowCallbackMock.mockReturnValue(setRow);
+
+    const result = renderHook(() => useCreateChatShortcut());
+    expect(result.result.current({ title: "t", content: "c" })).toBeNull();
+    expect(setRow).not.toHaveBeenCalled();
+  });
+
+  it("creates shortcut with generated id and payload", () => {
+    useValuesMock.mockReturnValue({ user_id: "user-1" });
+    const setRow = vi.fn();
+    useSetRowCallbackMock.mockReturnValue(setRow);
+
+    const result = renderHook(() => useCreateChatShortcut());
+    const createdId = result.result.current({
+      title: "Title",
+      content: "Body",
+    });
+
+    expect(typeof createdId).toBe("string");
+    expect(createdId).not.toBeNull();
+    expect(setRow).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: createdId,
+        user_id: "user-1",
+        title: "Title",
+        content: "Body",
+      }),
+    );
+  });
+});
diff --git a/apps/desktop/src/chat_shortcuts/hooks.ts b/apps/desktop/src/chat_shortcuts/hooks.ts
new file mode 100644
index 0000000000..4240e447db
--- /dev/null
+++ b/apps/desktop/src/chat_shortcuts/hooks.ts
@@ -0,0 +1,97 @@
+import { useCallback, useMemo } from "react";
+
+import type { ChatShortcut } from "@hypr/store";
+
+import * as main from "~/store/tinybase/store/main";
+
+// Storage boundary for chat-shortcut reads and mutations used by UI.
+// Hook signatures are backend-neutral to support seamless storage swaps.
+export type UserShortcut = ChatShortcut & { id: string };
+
+export function useChatShortcuts(): UserShortcut[] {
+  const shortcuts = main.UI.useResultTable(
+    main.QUERIES.visibleChatShortcuts,
+    main.STORE_ID,
+  );
+
+  return useMemo(() => {
+    return Object.entries(shortcuts as Record<string, ChatShortcut>).map(
+      ([id, shortcut]) => ({
+        id,
+        ...shortcut,
+      }),
+    );
+  }, [shortcuts]);
+}
+
+export function useChatShortcutCell(
+  id: string,
+  field: "title" | "content",
+): string {
+  const value = main.UI.useCell("chat_shortcuts", id, field, main.STORE_ID);
+  return (value as string | undefined) ?? "";
+}
+
+export function useCreateChatShortcut(): (args: {
+  title: string;
+  content: string;
+}) => string | null {
+  const { user_id } = main.UI.useValues(main.STORE_ID);
+
+  const setRow = main.UI.useSetRowCallback(
+    "chat_shortcuts",
+    (p: {
+      id: string;
+      user_id: string;
+      created_at: string;
+      title: string;
+      content: string;
+    }) => p.id,
+    (p: {
+      id: string;
+      user_id: string;
+      created_at: string;
+      title: string;
+      content: string;
+    }) => ({
+      user_id: p.user_id,
+      created_at: p.created_at,
+      title: p.title,
+      content: p.content,
+    }),
+    [],
+    main.STORE_ID,
+  );
+
+  return useCallback(
+    ({ title, content }) => {
+      if (!user_id) return null;
+      const id = crypto.randomUUID();
+      setRow({
+        id,
+        user_id,
+        created_at: new Date().toISOString(),
+        title,
+        content,
+      });
+      return id;
+    },
+    [user_id, setRow],
+  );
+}
+
+export function useUpdateChatShortcut(
+  id: string,
+): (row: { title?: string; content?: string }) => void {
+  return main.UI.useSetPartialRowCallback(
+    "chat_shortcuts",
+    id,
+    (row: { title?: string; content?: string }) => row,
+    [id],
+    main.STORE_ID,
+  );
+}
+
+export function useDeleteChatShortcut(id: string): () => void {
+  return main.UI.useDelRowCallback("chat_shortcuts", () => id, main.STORE_ID);
+}
diff --git a/apps/desktop/src/chat_shortcuts/index.tsx b/apps/desktop/src/chat_shortcuts/index.tsx
index 1f3e877897..f7e32e3de4 100644
--- a/apps/desktop/src/chat_shortcuts/index.tsx
+++ b/apps/desktop/src/chat_shortcuts/index.tsx
@@ -1,7 +1,6 @@
 import { Globe, MessageSquare, Plus, Search, X } from "lucide-react";
 import { useCallback, useMemo, useState } from "react";
 
-import type { ChatShortcut } from "@hypr/store";
 import { Button } from "@hypr/ui/components/ui/button";
 import { Switch } from "@hypr/ui/components/ui/switch";
 import {
@@ -13,10 +12,14 @@ import { cn } from "@hypr/utils";
 
 import { ChatShortcutDetailsColumn } from "./details";
 
+import {
+  useChatShortcuts,
+  useCreateChatShortcut,
+  type UserShortcut,
+} from "~/chat_shortcuts/hooks";
 import { StandardTabWrapper } from "~/shared/main";
 import { type TabItem, TabItemBase } from "~/shared/tabs";
 import { ResourceListLayout, useWebResources } from "~/shared/ui/resource-list";
-import * as main from "~/store/tinybase/store/main";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
 
 export const TabItemChatShortcut: TabItem<
@@ -69,31 +72,13 @@ export type WebShortcut = {
   prompt: string;
 };
 
-type UserShortcut = ChatShortcut & { id: string };
-
-function useChatShortcuts(): UserShortcut[] {
-  const shortcuts = main.UI.useResultTable(
-    main.QUERIES.visibleChatShortcuts,
-    main.STORE_ID,
-  );
-
-  return useMemo(() => {
-    return Object.entries(shortcuts as Record<string, ChatShortcut>).map(
-      ([id, shortcut]) => ({
-        id,
-        ...shortcut,
-      }),
-    );
-  }, [shortcuts]);
-}
-
 function ChatShortcutView({
   tab,
 }: {
   tab: Extract<Tab, { type: "chat_shortcuts" }>;
 }) {
   const updateTabState = useTabs((state) => state.updateChatShortcutsTabState);
-  const { user_id } = main.UI.useValues(main.STORE_ID);
+  const createShortcut = useCreateChatShortcut();
 
   const userShortcuts = useChatShortcuts();
   const { data: webShortcuts = [], isLoading: isWebLoading } =
@@ -138,45 +123,13 @@ function ChatShortcutView({
   const selectedWebShortcut =
     selectedWebIndex !== null ? (webShortcuts[selectedWebIndex] ?? null) : null;
 
-  const setRow = main.UI.useSetRowCallback(
-    "chat_shortcuts",
-    (p: {
-      id: string;
-      user_id: string;
-      created_at: string;
-      title: string;
-      content: string;
-    }) => p.id,
-    (p: {
-      id: string;
-      user_id: string;
-      created_at: string;
-      title: string;
-      content: string;
-    }) => ({
-      user_id: p.user_id,
-      created_at: p.created_at,
-      title: p.title,
-      content: p.content,
-    }),
-    [],
-    main.STORE_ID,
-  );
-
   const handleCloneShortcut = useCallback(
     (shortcut: WebShortcut) => {
-      if (!user_id) return;
-
-      const newId = crypto.randomUUID();
-      const now = new Date().toISOString();
-
-      setRow({
-        id: newId,
-        user_id,
-        created_at: now,
+      const newId = createShortcut({
         title: shortcut.title,
         content: shortcut.prompt,
       });
+      if (!newId) return;
 
       updateTabState(tab, {
         isWebMode: false,
@@ -184,23 +137,19 @@ function ChatShortcutView({
         selectedWebIndex: null,
       });
     },
-    [user_id, setRow, updateTabState, tab],
+    [createShortcut, updateTabState, tab],
   );
 
   const handleAddNew = useCallback(() => {
-    if (!user_id) return;
-
-    const newId = crypto.randomUUID();
-    const now = new Date().toISOString();
-
-    setRow({ id: newId, user_id, created_at: now, title: "", content: "" });
+    const newId = createShortcut({ title: "", content: "" });
+    if (!newId) return;
 
     updateTabState(tab, {
       isWebMode: false,
       selectedMineId: newId,
       selectedWebIndex: null,
     });
-  }, [user_id, setRow, updateTabState, tab]);
+  }, [createShortcut, updateTabState, tab]);
 
   return (
     <ResourceListLayout
diff --git a/apps/desktop/src/composer/index.tsx b/apps/desktop/src/composer/index.tsx
index 8756d0fe42..6291f5e8fa 100644
--- a/apps/desktop/src/composer/index.tsx
+++ b/apps/desktop/src/composer/index.tsx
@@ -20,22 +20,18 @@ import {
 } from "~/chat/components/input/hooks";
 import { ChatSession } from "~/chat/components/session-provider";
 import { dedupeByKey, type ContextRef } from "~/chat/context/entities";
-import { useChatActions } from "~/chat/store/use-chat-actions";
+import { useChatGroupTitle } from "~/chat/hooks/chat-groups";
+import { useChatActions } from "~/chat/hooks/use-chat-actions";
 import { useShell } from "~/contexts/shell";
 import { ChatEditor, type ChatEditorHandle } from "~/editor/chat";
 import type { PlaceholderFunction } from "~/editor/plugins";
-import * as main from "~/store/tinybase/store/main";
+import { useCurrentUserId } from "~/session/hooks/globals";
 
 export function ComposerScreen() {
   const { chat } = useShell();
   const model = useLanguageModel("chat");
-  const { user_id } = main.UI.useValues(main.STORE_ID);
-  const currentTitle = main.UI.useCell(
-    "chat_groups",
-    chat.groupId ?? "",
-    "title",
-    main.STORE_ID,
-  );
+  const user_id = useCurrentUserId();
+  const currentTitle = useChatGroupTitle(chat.groupId);
   const { handleSendMessage } = useChatActions({
     groupId: chat.groupId,
     onGroupCreated: chat.setGroupId,
diff --git a/apps/desktop/src/contacts/details.tsx b/apps/desktop/src/contacts/details.tsx
index 1ae639dc6f..995d755f08 100644
--- a/apps/desktop/src/contacts/details.tsx
+++ b/apps/desktop/src/contacts/details.tsx
@@ -21,7 +21,18 @@ import { cn } from "@hypr/utils";
 
 import { getContactBgClass } from "./shared";
 
-import * as main from "~/store/tinybase/store/main";
+import {
+  useCreateOrganization,
+  useHuman,
+  useHumanCell,
+  useMergeContacts,
+  useOrganization,
+  usePersonDuplicatesByEmail,
+  usePersonSessions,
+  useSetHumanOrgId,
+  useUpdateHumanStringCell,
+  useVisibleOrganizationList,
+} from "~/contacts/hooks";
 
 export function DetailsColumn({
   selectedHumanId,
@@ -30,170 +41,29 @@ export function DetailsColumn({
   selectedHumanId?: string | null;
   handleSessionClick: (id: string) => void;
 }) {
-  const selectedPersonData = main.UI.useRow(
-    "humans",
-    selectedHumanId ?? "",
-    main.STORE_ID,
-  );
-  const mappingIdsByHuman = main.UI.useSliceRowIds(
-    main.INDEXES.sessionsByHuman,
-    selectedHumanId ?? "",
-    main.STORE_ID,
+  const selectedPerson = useHuman(selectedHumanId);
+  const personSessions = usePersonSessions(selectedHumanId);
+  const duplicatesWithData = usePersonDuplicatesByEmail(
+    selectedHumanId,
+    selectedPerson?.email,
   );
 
-  const allMappings = main.UI.useTable(
-    "mapping_session_participant",
-    main.STORE_ID,
-  );
-  const allSessions = main.UI.useTable("sessions", main.STORE_ID);
-
-  const personSessions = React.useMemo(() => {
-    if (!mappingIdsByHuman || mappingIdsByHuman.length === 0) {
-      return [];
-    }
-
-    return mappingIdsByHuman
-      .map((mappingId: string) => {
-        const mapping = allMappings[mappingId];
-        if (!mapping || !mapping.session_id || mapping.source === "excluded") {
-          return null;
-        }
-
-        const sessionId = mapping.session_id as string;
-        const session = allSessions[sessionId];
-        if (!session) {
-          return null;
-        }
-
-        return {
-          id: sessionId,
-          ...session,
-        };
-      })
-      .filter(
-        (session: any): session is NonNullable<typeof session> =>
-          session !== null,
-      );
-  }, [mappingIdsByHuman, allMappings, allSessions]);
-
-  const email = main.UI.useCell(
-    "humans",
-    selectedHumanId ?? "",
-    "email",
-    main.STORE_ID,
-  ) as string | undefined;
-
-  const duplicateHumanIds = main.UI.useSliceRowIds(
-    main.INDEXES.humansByEmail,
-    email ?? "",
-    main.STORE_ID,
-  );
-
-  const duplicates = React.useMemo(() => {
-    if (!email || !duplicateHumanIds || duplicateHumanIds.length <= 1) {
-      return [];
-    }
-    return duplicateHumanIds.filter((id) => id !== selectedHumanId);
-  }, [email, duplicateHumanIds, selectedHumanId]);
-
-  const allHumans = main.UI.useTable("humans", main.STORE_ID);
-
-  const duplicatesWithData = React.useMemo(() => {
-    return duplicates
-      .map((id) => {
-        const data = allHumans[id];
-        if (!data) return null;
-        return { id, ...data };
-      })
-      .filter((dup): dup is NonNullable<typeof dup> => dup !== null);
-  }, [duplicates, allHumans]);
-
-  const store = main.UI.useStore(main.STORE_ID);
-
+  const mergeContacts = useMergeContacts();
   const handleMergeContacts = useCallback(
     (duplicateId: string) => {
-      if (!store || !selectedHumanId) return;
-
-      const userId = store.getValue("user_id") as string;
-
-      let primaryId = selectedHumanId;
-      let dupId = duplicateId;
-
-      if (duplicateId === userId) {
-        primaryId = duplicateId;
-        dupId = selectedHumanId;
-      }
-
-      const duplicateData = store.getRow("humans", dupId);
-      const primaryData = store.getRow("humans", primaryId);
-
-      store.transaction(() => {
-        const allMappingIds = store.getRowIds("mapping_session_participant");
-        allMappingIds.forEach((mappingId) => {
-          const mapping = store.getRow(
-            "mapping_session_participant",
-            mappingId,
-          );
-          if (mapping.human_id === dupId) {
-            store.setPartialRow("mapping_session_participant", mappingId, {
-              human_id: primaryId,
-            });
-          }
-        });
-
-        if (duplicateData && primaryData) {
-          const mergedFields: Record<string, any> = {};
-
-          if (duplicateData.job_title) {
-            if (primaryData.job_title) {
-              mergedFields.job_title = `${primaryData.job_title}, ${duplicateData.job_title}`;
-            } else {
-              mergedFields.job_title = duplicateData.job_title;
-            }
-          }
-
-          if (duplicateData.linkedin_username) {
-            if (primaryData.linkedin_username) {
-              mergedFields.linkedin_username = `${primaryData.linkedin_username}, ${duplicateData.linkedin_username}`;
-            } else {
-              mergedFields.linkedin_username = duplicateData.linkedin_username;
-            }
-          }
-
-          if (duplicateData.memo) {
-            if (primaryData.memo) {
-              mergedFields.memo = `${primaryData.memo}, ${duplicateData.memo}`;
-            } else {
-              mergedFields.memo = duplicateData.memo;
-            }
-          }
-
-          if (!primaryData.org_id && duplicateData.org_id) {
-            mergedFields.org_id = duplicateData.org_id;
-          }
-
-          if (Object.keys(mergedFields).length > 0) {
-            store.setPartialRow("humans", primaryId, mergedFields);
-          }
-        }
-
-        store.delRow("humans", dupId);
-      });
+      if (!selectedHumanId) return;
+      mergeContacts({ primaryId: selectedHumanId, duplicateId });
     },
-    [store, selectedHumanId],
+    [mergeContacts, selectedHumanId],
   );
 
-  const facehashName = String(
-    selectedPersonData?.name ||
-      selectedPersonData?.email ||
-      selectedHumanId ||
-      "",
-  );
+  const facehashName =
+    selectedPerson?.name || selectedPerson?.email || selectedHumanId || "";
   const bgClass = getContactBgClass(facehashName);
 
   return (
     <div className="flex h-full flex-1 flex-col">
-      {selectedPersonData && selectedHumanId ? (
+      {selectedPerson && selectedHumanId ? (
         <>
           <div className="flex items-center justify-center border-b border-neutral-200 py-6">
             <div className={cn(["rounded-full", bgClass])}>
@@ -232,19 +102,17 @@ export function DetailsColumn({
                         <div
                           className={cn([
                             "shrink-0 rounded-full",
-                            getContactBgClass(
-                              String(dup.name || dup.email || dup.id),
-                            ),
+                            getContactBgClass(dup.name || dup.email || dup.id),
                           ])}
                         >
                           <Facehash
-                            name={String(dup.name || dup.email || dup.id)}
+                            name={dup.name || dup.email || dup.id}
                             size={32}
                             interactive={false}
                             showInitial={false}
                             colorClasses={[
                               getContactBgClass(
-                                String(dup.name || dup.email || dup.id),
+                                dup.name || dup.email || dup.id,
                               ),
                             ]}
                           />
@@ -314,7 +182,7 @@ export function DetailsColumn({
               </h3>
               <div className="flex flex-col gap-2">
                 {personSessions.length > 0 ? (
-                  personSessions.map((session: any) => (
+                  personSessions.map((session) => (
                     <button
                       key={session.id}
                       onClick={() => handleSessionClick(session.id)}
@@ -326,14 +194,9 @@ export function DetailsColumn({
                           {session.title || "Untitled Note"}
                         </span>
                       </div>
-                      {session.summary && (
-                        <p className="mt-1 line-clamp-2 text-xs text-neutral-600">
-                          {session.summary}
-                        </p>
-                      )}
-                      {session.created_at && (
+                      {session.createdAt && (
                         <div className="mt-1 text-xs text-neutral-500">
-                          {new Date(session.created_at).toLocaleDateString()}
+                          {new Date(session.createdAt).toLocaleDateString()}
                         </div>
                       )}
                     </button>
@@ -361,20 +224,12 @@ export function DetailsColumn({
 }
 
 function EditablePersonNameField({ personId }: { personId: string }) {
-  const value = main.UI.useCell("humans", personId, "name", main.STORE_ID);
-
-  const handleChange = main.UI.useSetCellCallback(
-    "humans",
-    personId,
-    "name",
-    (e: React.ChangeEvent<HTMLInputElement>) => e.target.value,
-    [],
-    main.STORE_ID,
-  );
+  const value = useHumanCell(personId, "name");
+  const handleChange = useUpdateHumanStringCell(personId, "name");
 
   return (
     <Input
-      value={(value as string) || ""}
+      value={value}
       onChange={handleChange}
       placeholder="Name"
       className="h-7 border-none p-0 text-base shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
@@ -383,23 +238,15 @@ function EditablePersonNameField({ personId }: { personId: string }) {
 }
 
 function EditablePersonJobTitleField({ personId }: { personId: string }) {
-  const value = main.UI.useCell("humans", personId, "job_title", main.STORE_ID);
-
-  const handleChange = main.UI.useSetCellCallback(
-    "humans",
-    personId,
-    "job_title",
-    (e: React.ChangeEvent<HTMLInputElement>) => e.target.value,
-    [],
-    main.STORE_ID,
-  );
+  const value = useHumanCell(personId, "job_title");
+  const handleChange = useUpdateHumanStringCell(personId, "job_title");
 
   return (
     <div className="flex items-center border-b border-neutral-200 px-4 py-3">
       <div className="w-28 text-sm text-neutral-500">Job Title</div>
       <div className="flex-1">
         <Input
-          value={(value as string) || ""}
+          value={value}
           onChange={handleChange}
           placeholder="Software Engineer"
           className="h-7 border-none p-0 text-base shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
@@ -410,16 +257,8 @@ function EditablePersonJobTitleField({ personId }: { personId: string }) {
 }
 
 function EditablePersonEmailField({ personId }: { personId: string }) {
-  const value = main.UI.useCell("humans", personId, "email", main.STORE_ID);
-
-  const handleChange = main.UI.useSetCellCallback(
-    "humans",
-    personId,
-    "email",
-    (e: React.ChangeEvent<HTMLInputElement>) => e.target.value,
-    [],
-    main.STORE_ID,
-  );
+  const value = useHumanCell(personId, "email");
+  const handleChange = useUpdateHumanStringCell(personId, "email");
 
   return (
     <div className="flex items-center border-b border-neutral-200 px-4 py-3">
@@ -427,7 +266,7 @@ function EditablePersonEmailField({ personId }: { personId: string }) {
       <div className="flex-1">
         <Input
           type="email"
-          value={(value as string) || ""}
+          value={value}
           onChange={handleChange}
           placeholder="john@example.com"
           className="h-7 border-none p-0 text-base shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
@@ -438,28 +277,15 @@ function EditablePersonEmailField({ personId }: { personId: string }) {
 }
 
 function EditablePersonLinkedInField({ personId }: { personId: string }) {
-  const value = main.UI.useCell(
-    "humans",
-    personId,
-    "linkedin_username",
-    main.STORE_ID,
-  );
-
-  const handleChange = main.UI.useSetCellCallback(
-    "humans",
-    personId,
-    "linkedin_username",
-    (e: React.ChangeEvent<HTMLInputElement>) => e.target.value,
-    [],
-    main.STORE_ID,
-  );
+  const value = useHumanCell(personId, "linkedin_username");
+  const handleChange = useUpdateHumanStringCell(personId, "linkedin_username");
 
   return (
     <div className="flex items-center border-b border-neutral-200 px-4 py-3">
       <div className="w-28 text-sm text-neutral-500">LinkedIn</div>
       <div className="flex-1">
         <Input
-          value={(value as string) || ""}
+          value={value}
           onChange={handleChange}
           placeholder="https://www.linkedin.com/in/johntopia/"
           className="h-7 border-none p-0 text-base shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
@@ -470,23 +296,15 @@ function EditablePersonLinkedInField({ personId }: { personId: string }) {
 }
 
 function EditablePersonMemoField({ personId }: { personId: string }) {
-  const value = main.UI.useCell("humans", personId, "memo", main.STORE_ID);
-
-  const handleChange = main.UI.useSetCellCallback(
-    "humans",
-    personId,
-    "memo",
-    (e: React.ChangeEvent<HTMLTextAreaElement>) => e.target.value,
-    [],
-    main.STORE_ID,
-  );
+  const value = useHumanCell(personId, "memo");
+  const handleChange = useUpdateHumanStringCell(personId, "memo");
 
   return (
     <div className="flex border-b border-neutral-200 px-4 py-3">
       <div className="w-28 pt-2 text-sm text-neutral-500">Notes</div>
       <div className="flex-1">
         <Textarea
-          value={(value as string) || ""}
+          value={value}
           onChange={handleChange}
           placeholder="Add notes about this contact..."
           className="min-h-[80px] resize-none border-none px-0 py-2 text-base shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
@@ -499,23 +317,9 @@ function EditablePersonMemoField({ personId }: { personId: string }) {
 
 function EditPersonOrganizationSelector({ personId }: { personId: string }) {
   const [open, setOpen] = useState(false);
-  const orgId = main.UI.useCell("humans", personId, "org_id", main.STORE_ID) as
-    | string
-    | null;
-  const organization = main.UI.useRow(
-    "organizations",
-    orgId ?? "",
-    main.STORE_ID,
-  );
-
-  const handleChange = main.UI.useSetCellCallback(
-    "humans",
-    personId,
-    "org_id",
-    (newOrgId: string | null) => newOrgId ?? "",
-    [],
-    main.STORE_ID,
-  );
+  const orgId = useHumanCell(personId, "org_id");
+  const organization = useOrganization(orgId || null);
+  const handleChange = useSetHumanOrgId(personId);
 
   const handleRemoveOrganization = () => {
     handleChange(null);
@@ -568,40 +372,19 @@ function OrganizationControl({
 }) {
   const [searchTerm, setSearchTerm] = useState("");
   const [highlightedIndex, setHighlightedIndex] = useState(-1);
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
 
-  const organizationsData = main.UI.useResultTable(
-    main.QUERIES.visibleOrganizations,
-    main.STORE_ID,
-  );
-
-  const allOrganizations = Object.entries(organizationsData).map(
-    ([id, data]) => ({
-      id,
-      ...(data as any),
-    }),
-  );
+  const allOrganizations = useVisibleOrganizationList();
 
   const organizations = searchTerm.trim()
-    ? allOrganizations.filter((org: any) =>
+    ? allOrganizations.filter((org) =>
         org.name.toLowerCase().includes(searchTerm.toLowerCase()),
       )
     : allOrganizations;
 
-  const showCreateOption = searchTerm.trim() && organizations.length === 0;
+  const showCreateOption = !!searchTerm.trim() && organizations.length === 0;
   const itemCount = organizations.length + (showCreateOption ? 1 : 0);
 
-  const createOrganization = main.UI.useSetRowCallback(
-    "organizations",
-    (p: { name: string; orgId: string }) => p.orgId,
-    (p: { name: string; orgId: string }) => ({
-      user_id: userId || "",
-      name: p.name,
-      created_at: new Date().toISOString(),
-    }),
-    [userId],
-    main.STORE_ID,
-  );
+  const createOrganization = useCreateOrganization();
 
   const handleCreateOrganization = () => {
     const orgId = crypto.randomUUID();
@@ -661,7 +444,7 @@ function OrganizationControl({
 
           {searchTerm.trim() && (
             <div className="flex w-full flex-col overflow-hidden rounded-xs border border-neutral-200">
-              {organizations.map((org: any, index: number) => (
+              {organizations.map((org, index) => (
                 <button
                   key={org.id}
                   type="button"
@@ -709,7 +492,7 @@ function OrganizationControl({
 
           {!searchTerm.trim() && organizations.length > 0 && (
             <div className="custom-scrollbar flex max-h-[40vh] w-full flex-col overflow-hidden overflow-y-auto rounded-xs border border-neutral-200">
-              {organizations.map((org: any, index: number) => (
+              {organizations.map((org, index) => (
                 <button
                   key={org.id}
                   type="button"
diff --git a/apps/desktop/src/contacts/hooks.test.tsx b/apps/desktop/src/contacts/hooks.test.tsx
new file mode 100644
index 0000000000..1c1da87a42
--- /dev/null
+++ b/apps/desktop/src/contacts/hooks.test.tsx
@@ -0,0 +1,101 @@
+import { renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type ContactsFixture = {
+  tables: Record<string, Record<string, Record<string, unknown>>>;
+  slices: Record<string, Record<string, string[]>>;
+};
+
+const { fixture, resetFixture, setFixture } = vi.hoisted(() => {
+  const fixture: ContactsFixture = {
+    tables: {},
+    slices: {},
+  };
+
+  return {
+    fixture,
+    resetFixture: () => {
+      fixture.tables = {};
+      fixture.slices = {};
+    },
+    setFixture: (next: Partial<ContactsFixture>) => {
+      fixture.tables = next.tables ?? {};
+      fixture.slices = next.slices ?? {};
+    },
+  };
+});
+
+vi.mock("~/store/tinybase/store/main", () => ({
+  STORE_ID: "main",
+  INDEXES: {
+    humansByOrg: "humansByOrg",
+  },
+  QUERIES: {
+    visibleOrganizations: "visibleOrganizations",
+    visibleHumans: "visibleHumans",
+  },
+  UI: {
+    useRow: vi.fn(() => ({})),
+    useCell: vi.fn(() => undefined),
+    useTable: vi.fn((table: string) => fixture.tables[table] ?? {}),
+    useResultTable: vi.fn(() => ({})),
+    useResultSortedRowIds: vi.fn(() => []),
+    useSliceRowIds: vi.fn(
+      (index: string, sliceId: string) =>
+        fixture.slices[index]?.[sliceId] ?? [],
+    ),
+    useStore: vi.fn(() => null),
+    useValue: vi.fn(() => undefined),
+    useSetRowCallback: vi.fn(),
+    useDelRowCallback: vi.fn(),
+  },
+}));
+
+import { useHumansByIds, useOrganizationMembers } from "./hooks";
+
+describe("contacts boundary hooks", () => {
+  beforeEach(() => {
+    resetFixture();
+  });
+
+  it("returns only requested humans for id-scoped reads", () => {
+    setFixture({
+      tables: {
+        humans: {
+          "human-1": { name: "Alice", email: "a@example.com" },
+          "human-2": { name: "Bob", email: "b@example.com" },
+        },
+      },
+    });
+
+    const result = renderHook(() => useHumansByIds(["human-2"]));
+    expect(result.result.current).toEqual({
+      "human-2": expect.objectContaining({
+        id: "human-2",
+        name: "Bob",
+      }),
+    });
+  });
+
+  it("builds organization members from org-specific ids", () => {
+    setFixture({
+      tables: {
+        humans: {
+          "human-1": { name: "Alice", email: "a@example.com", org_id: "org-1" },
+          "human-2": { name: "Bob", email: "b@example.com", org_id: "org-1" },
+        },
+      },
+      slices: {
+        humansByOrg: {
+          "org-1": ["human-2"],
+        },
+      },
+    });
+
+    const result = renderHook(() => useOrganizationMembers("org-1"));
+    expect(result.result.current).toHaveLength(1);
+    expect(result.result.current[0]).toEqual(
+      expect.objectContaining({ id: "human-2", name: "Bob" }),
+    );
+  });
+});
diff --git a/apps/desktop/src/contacts/hooks.ts b/apps/desktop/src/contacts/hooks.ts
new file mode 100644
index 0000000000..f0d7901735
--- /dev/null
+++ b/apps/desktop/src/contacts/hooks.ts
@@ -0,0 +1,563 @@
+import { useCallback, useMemo } from "react";
+
+import * as main from "~/store/tinybase/store/main";
+
+// Storage boundary for contacts-domain consumers. Expose normalized DTOs and
+// callback-style mutations so consumer components stay storage-agnostic.
+export type Human = {
+  id: string;
+  name: string;
+  email: string;
+  orgId: string;
+  jobTitle: string;
+  linkedinUsername: string;
+  memo: string;
+  pinned: boolean;
+  pinOrder: number;
+  createdAt: string;
+  userId: string;
+};
+
+export type Organization = {
+  id: string;
+  name: string;
+  pinned: boolean;
+  pinOrder: number;
+  createdAt: string;
+  userId: string;
+};
+
+type HumanStringField =
+  | "name"
+  | "email"
+  | "org_id"
+  | "job_title"
+  | "linkedin_username"
+  | "memo"
+  | "created_at"
+  | "user_id";
+type OrganizationStringField = "name" | "created_at" | "user_id";
+
+export type PersonSession = {
+  id: string;
+  title: string;
+  createdAt: string;
+};
+
+export type PersonDuplicate = {
+  id: string;
+  name: string;
+  email: string;
+};
+
+export type SortDirection =
+  | "alphabetical"
+  | "reverse-alphabetical"
+  | "newest"
+  | "oldest";
+export type PinnedContactItem =
+  | { kind: "person"; id: string }
+  | { kind: "organization"; id: string };
+
+function readHuman(
+  row: Record<string, unknown> | undefined,
+  id: string,
+): Human | null {
+  if (!row || Object.keys(row).length === 0) return null;
+  return {
+    id,
+    name: String(row.name ?? ""),
+    email: String(row.email ?? ""),
+    orgId: String(row.org_id ?? ""),
+    jobTitle: String(row.job_title ?? ""),
+    linkedinUsername: String(row.linkedin_username ?? ""),
+    memo: String(row.memo ?? ""),
+    pinned: Boolean(row.pinned),
+    pinOrder: Number(row.pin_order ?? 0),
+    createdAt: String(row.created_at ?? ""),
+    userId: String(row.user_id ?? ""),
+  };
+}
+
+function readOrganization(
+  row: Record<string, unknown> | undefined,
+  id: string,
+): Organization | null {
+  if (!row || Object.keys(row).length === 0) return null;
+  return {
+    id,
+    name: String(row.name ?? ""),
+    pinned: Boolean(row.pinned),
+    pinOrder: Number(row.pin_order ?? 0),
+    createdAt: String(row.created_at ?? ""),
+    userId: String(row.user_id ?? ""),
+  };
+}
+
+// --- reactive reads -------------------------------------------------------
+
+export function useHuman(id: string | null | undefined): Human | null {
+  const row = main.UI.useRow("humans", id ?? "", main.STORE_ID);
+  return useMemo(() => (id ? readHuman(row, id) : null), [id, row]);
+}
+
+export function useOrganization(
+  id: string | null | undefined,
+): Organization | null {
+  const row = main.UI.useRow("organizations", id ?? "", main.STORE_ID);
+  return useMemo(() => (id ? readOrganization(row, id) : null), [id, row]);
+}
+
+export function useHumanCell<K extends HumanStringField>(
+  id: string,
+  field: K,
+): string {
+  const v = main.UI.useCell("humans", id, field, main.STORE_ID);
+  return (v as string | undefined) ?? "";
+}
+
+export function useOrganizationCell<K extends OrganizationStringField>(
+  id: string,
+  field: K,
+): string {
+  const v = main.UI.useCell("organizations", id, field, main.STORE_ID);
+  return (v as string | undefined) ?? "";
+}
+
+export function useAllHumans(): Record<string, Human> {
+  const table = main.UI.useTable("humans", main.STORE_ID);
+  return useMemo(() => {
+    const out: Record<string, Human> = {};
+    for (const [id, row] of Object.entries(table)) {
+      const h = readHuman(row as Record<string, unknown>, id);
+      if (h) out[id] = h;
+    }
+    return out;
+  }, [table]);
+}
+
+export function useHumansByIds(ids: string[]): Record<string, Human> {
+  const table = main.UI.useTable("humans", main.STORE_ID);
+  return useMemo(() => {
+    const out: Record<string, Human> = {};
+    for (const id of ids) {
+      const row = table[id];
+      const human = readHuman(row as Record<string, unknown> | undefined, id);
+      if (human) out[id] = human;
+    }
+    return out;
+  }, [ids, table]);
+}
+
+export function useAllOrganizations(): Record<string, Organization> {
+  const table = main.UI.useTable("organizations", main.STORE_ID);
+  return useMemo(() => {
+    const out: Record<string, Organization> = {};
+    for (const [id, row] of Object.entries(table)) {
+      const o = readOrganization(row as Record<string, unknown>, id);
+      if (o) out[id] = o;
+    }
+    return out;
+  }, [table]);
+}
+
+export function useOrganizationsByIds(
+  ids: string[],
+): Record<string, Organization> {
+  const table = main.UI.useTable("organizations", main.STORE_ID);
+  return useMemo(() => {
+    const out: Record<string, Organization> = {};
+    for (const id of ids) {
+      const row = table[id];
+      const organization = readOrganization(
+        row as Record<string, unknown> | undefined,
+        id,
+      );
+      if (organization) out[id] = organization;
+    }
+    return out;
+  }, [ids, table]);
+}
+
+export function useVisibleOrganizationList(): Organization[] {
+  const table = main.UI.useResultTable(
+    main.QUERIES.visibleOrganizations,
+    main.STORE_ID,
+  );
+  return useMemo(() => {
+    const out: Organization[] = [];
+    for (const [id, row] of Object.entries(table)) {
+      const o = readOrganization(row as Record<string, unknown>, id);
+      if (o) out.push(o);
+    }
+    return out;
+  }, [table]);
+}
+
+export function useSortedVisibleHumanIds(
+  sortBy: "name" | "created_at",
+  descending: boolean,
+): string[] {
+  return main.UI.useResultSortedRowIds(
+    main.QUERIES.visibleHumans,
+    sortBy,
+    descending,
+    0,
+    undefined,
+    main.STORE_ID,
+  );
+}
+
+export function useSortedVisibleOrganizationIds(
+  sortBy: "name" | "created_at",
+  descending: boolean,
+): string[] {
+  return main.UI.useResultSortedRowIds(
+    main.QUERIES.visibleOrganizations,
+    sortBy,
+    descending,
+    0,
+    undefined,
+    main.STORE_ID,
+  );
+}
+
+export function useHumansByOrg(orgId: string | null | undefined): string[] {
+  return main.UI.useSliceRowIds(
+    main.INDEXES.humansByOrg,
+    orgId ?? "",
+    main.STORE_ID,
+  );
+}
+
+export function useOrganizationMembers(
+  orgId: string | null | undefined,
+): Human[] {
+  const humanIds = useHumansByOrg(orgId);
+  const humansById = useHumansByIds(humanIds);
+
+  return useMemo(
+    () =>
+      humanIds
+        .map((humanId) => humansById[humanId])
+        .filter((human): human is Human => Boolean(human)),
+    [humanIds, humansById],
+  );
+}
+
+// --- composed reads -------------------------------------------------------
+
+export function usePersonSessions(
+  humanId: string | null | undefined,
+): PersonSession[] {
+  const mappingIds = main.UI.useSliceRowIds(
+    main.INDEXES.sessionsByHuman,
+    humanId ?? "",
+    main.STORE_ID,
+  );
+  const allMappings = main.UI.useTable(
+    "mapping_session_participant",
+    main.STORE_ID,
+  );
+  const allSessions = main.UI.useTable("sessions", main.STORE_ID);
+
+  return useMemo(() => {
+    if (!mappingIds || mappingIds.length === 0) return [];
+    const out: PersonSession[] = [];
+    for (const mappingId of mappingIds) {
+      const mapping = allMappings[mappingId];
+      if (!mapping || !mapping.session_id || mapping.source === "excluded") {
+        continue;
+      }
+      const sessionId = mapping.session_id as string;
+      const session = allSessions[sessionId];
+      if (!session) continue;
+      out.push({
+        id: sessionId,
+        title: String(session.title ?? ""),
+        createdAt: String(session.created_at ?? ""),
+      });
+    }
+    return out;
+  }, [mappingIds, allMappings, allSessions]);
+}
+
+export function usePersonDuplicatesByEmail(
+  humanId: string | null | undefined,
+  email: string | undefined,
+): PersonDuplicate[] {
+  const duplicateIds = main.UI.useSliceRowIds(
+    main.INDEXES.humansByEmail,
+    email ?? "",
+    main.STORE_ID,
+  );
+  const allHumans = main.UI.useTable("humans", main.STORE_ID);
+
+  return useMemo(() => {
+    if (!email || !duplicateIds || duplicateIds.length <= 1) return [];
+    const out: PersonDuplicate[] = [];
+    for (const id of duplicateIds) {
+      if (id === humanId) continue;
+      const row = allHumans[id];
+      if (!row) continue;
+      out.push({
+        id,
+        name: String(row.name ?? ""),
+        email: String(row.email ?? ""),
+      });
+    }
+    return out;
+  }, [humanId, email, duplicateIds, allHumans]);
+}
+
+// --- writes ---------------------------------------------------------------
+
+export function useUpdateHumanStringCell<K extends HumanStringField>(
+  id: string,
+  field: K,
+): (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (e) => {
+      if (!store) return;
+      store.setPartialRow("humans", id, {
+        [field]: e.target.value,
+      } as Record<string, string>);
+    },
+    [store, id, field],
+  );
+}
+
+export function useUpdateOrganizationStringCell<
+  K extends OrganizationStringField,
+>(
+  id: string,
+  field: K,
+): (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (e) => {
+      if (!store) return;
+      store.setPartialRow("organizations", id, {
+        [field]: e.target.value,
+      } as Record<string, string>);
+    },
+    [store, id, field],
+  );
+}
+
+export function useSetHumanOrgId(
+  humanId: string,
+): (orgId: string | null) => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (orgId) => {
+      if (!store) return;
+      store.setCell("humans", humanId, "org_id", orgId ?? "");
+    },
+    [store, humanId],
+  );
+}
+
+export function useCreateHuman(): (args: {
+  humanId: string;
+  name: string;
+}) => void {
+  const userId = main.UI.useValue("user_id", main.STORE_ID);
+  return main.UI.useSetRowCallback(
+    "humans",
+    (p: { humanId: string; name: string }) => p.humanId,
+    (p: { humanId: string; name: string }) => ({
+      user_id: userId || "",
+      created_at: new Date().toISOString(),
+      name: p.name,
+      email: "",
+      org_id: "",
+      job_title: "",
+      linkedin_username: "",
+      memo: "",
+      pinned: false,
+    }),
+    [userId],
+    main.STORE_ID,
+  );
+}
+
+export function useCreateOrganization(): (args: {
+  orgId: string;
+  name: string;
+}) => void {
+  const userId = main.UI.useValue("user_id", main.STORE_ID);
+  return main.UI.useSetRowCallback(
+    "organizations",
+    (p: { orgId: string; name: string }) => p.orgId,
+    (p: { orgId: string; name: string }) => ({
+      user_id: userId || "",
+      name: p.name,
+      created_at: new Date().toISOString(),
+    }),
+    [userId],
+    main.STORE_ID,
+  );
+}
+
+export function useDeleteHuman(): (id: string) => void {
+  return main.UI.useDelRowCallback("humans", (id: string) => id, main.STORE_ID);
+}
+
+export function useDeleteOrganization(): (id: string) => void {
+  return main.UI.useDelRowCallback(
+    "organizations",
+    (id: string) => id,
+    main.STORE_ID,
+  );
+}
+
+// --- composed writes ------------------------------------------------------
+
+function nextPinOrder(
+  humansTable: Record<string, Record<string, unknown>>,
+  orgsTable: Record<string, Record<string, unknown>>,
+): number {
+  const maxH = Object.values(humansTable).reduce(
+    (m, h) => Math.max(m, Number(h.pin_order ?? 0)),
+    0,
+  );
+  const maxO = Object.values(orgsTable).reduce(
+    (m, o) => Math.max(m, Number(o.pin_order ?? 0)),
+    0,
+  );
+  return Math.max(maxH, maxO) + 1;
+}
+
+export function useToggleHumanPin(humanId: string): () => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(() => {
+    if (!store) return;
+    const currentPinned = store.getCell("humans", humanId, "pinned");
+    if (currentPinned) {
+      store.setPartialRow("humans", humanId, {
+        pinned: false,
+        pin_order: 0,
+      });
+      return;
+    }
+    store.setPartialRow("humans", humanId, {
+      pinned: true,
+      pin_order: nextPinOrder(
+        store.getTable("humans"),
+        store.getTable("organizations"),
+      ),
+    });
+  }, [store, humanId]);
+}
+
+export function useToggleOrganizationPin(orgId: string): () => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(() => {
+    if (!store) return;
+    const currentPinned = store.getCell("organizations", orgId, "pinned");
+    if (currentPinned) {
+      store.setPartialRow("organizations", orgId, {
+        pinned: false,
+        pin_order: 0,
+      });
+      return;
+    }
+    store.setPartialRow("organizations", orgId, {
+      pinned: true,
+      pin_order: nextPinOrder(
+        store.getTable("humans"),
+        store.getTable("organizations"),
+      ),
+    });
+  }, [store, orgId]);
+}
+
+export function useReorderPinnedContacts(): (
+  ordered: PinnedContactItem[],
+) => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    (ordered) => {
+      if (!store) return;
+      store.transaction(() => {
+        ordered.forEach((item, index) => {
+          if (item.kind === "person") {
+            store.setCell("humans", item.id, "pin_order", index);
+          } else {
+            store.setCell("organizations", item.id, "pin_order", index);
+          }
+        });
+      });
+    },
+    [store],
+  );
+}
+
+export function useMergeContacts(): (args: {
+  primaryId: string;
+  duplicateId: string;
+}) => void {
+  const store = main.UI.useStore(main.STORE_ID);
+  return useCallback(
+    ({ primaryId, duplicateId }) => {
+      if (!store) return;
+
+      const userId = store.getValue("user_id") as string;
+
+      let keepId = primaryId;
+      let dropId = duplicateId;
+      if (duplicateId === userId) {
+        keepId = duplicateId;
+        dropId = primaryId;
+      }
+
+      const duplicateData = store.getRow("humans", dropId);
+      const primaryData = store.getRow("humans", keepId);
+
+      store.transaction(() => {
+        const allMappingIds = store.getRowIds("mapping_session_participant");
+        allMappingIds.forEach((mappingId) => {
+          const mapping = store.getRow(
+            "mapping_session_participant",
+            mappingId,
+          );
+          if (mapping.human_id === dropId) {
+            store.setPartialRow("mapping_session_participant", mappingId, {
+              human_id: keepId,
+            });
+          }
+        });
+
+        if (duplicateData && primaryData) {
+          const mergedFields: Record<string, string> = {};
+
+          const concatField = (
+            field: "job_title" | "linkedin_username" | "memo",
+          ) => {
+            const dup = duplicateData[field];
+            const pri = primaryData[field];
+            if (dup) {
+              mergedFields[field] = pri ? `${pri}, ${dup}` : String(dup);
+            }
+          };
+          concatField("job_title");
+          concatField("linkedin_username");
+          concatField("memo");
+
+          if (!primaryData.org_id && duplicateData.org_id) {
+            mergedFields.org_id = String(duplicateData.org_id);
+          }
+
+          if (Object.keys(mergedFields).length > 0) {
+            store.setPartialRow("humans", keepId, mergedFields);
+          }
+        }
+
+        store.delRow("humans", dropId);
+      });
+    },
+    [store],
+  );
+}
diff --git a/apps/desktop/src/contacts/humans.tsx b/apps/desktop/src/contacts/humans.tsx
index 69dbbf510b..6b569efe1c 100644
--- a/apps/desktop/src/contacts/humans.tsx
+++ b/apps/desktop/src/contacts/humans.tsx
@@ -1,8 +1,8 @@
 import { UserIcon } from "lucide-react";
 
+import { useHumanCell } from "~/contacts/hooks";
 import { StandardTabWrapper } from "~/shared/main";
 import { type TabItem, TabItemBase } from "~/shared/tabs";
-import * as main from "~/store/tinybase/store/main";
 import { type Tab } from "~/store/zustand/tabs";
 
 export const TabItemHuman: TabItem<Extract<Tab, { type: "humans" }>> = ({
@@ -15,12 +15,12 @@ export const TabItemHuman: TabItem<Extract<Tab, { type: "humans" }>> = ({
   handlePinThis,
   handleUnpinThis,
 }) => {
-  const title = main.UI.useCell("humans", tab.id, "name", main.STORE_ID);
+  const title = useHumanCell(tab.id, "name");
 
   return (
     <TabItemBase
       icon={<UserIcon className="h-4 w-4" />}
-      title={title ?? "Human"}
+      title={title || "Human"}
       selected={tab.active}
       pinned={tab.pinned}
       tabIndex={tabIndex}
diff --git a/apps/desktop/src/contacts/index.tsx b/apps/desktop/src/contacts/index.tsx
index 99f2250d7f..ad74400f64 100644
--- a/apps/desktop/src/contacts/index.tsx
+++ b/apps/desktop/src/contacts/index.tsx
@@ -6,9 +6,12 @@ import type { ContactsSelection } from "@hypr/plugin-windows";
 import { DetailsColumn } from "./details";
 import { OrganizationDetailsColumn } from "./organization-details";
 
+import {
+  useSortedVisibleHumanIds,
+  useSortedVisibleOrganizationIds,
+} from "~/contacts/hooks";
 import { StandardTabWrapper } from "~/shared/main";
 import { type TabItem, TabItemBase } from "~/shared/tabs";
-import * as main from "~/store/tinybase/store/main";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
 
 export const TabItemContact: TabItem<Extract<Tab, { type: "contacts" }>> = ({
@@ -72,23 +75,8 @@ function ContactView({ tab }: { tab: Extract<Tab, { type: "contacts" }> }) {
     [openCurrent],
   );
 
-  const allHumanIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleHumans,
-    "name",
-    false,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-
-  const allOrgIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleOrganizations,
-    "name",
-    false,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
+  const allHumanIds = useSortedVisibleHumanIds("name", false);
+  const allOrgIds = useSortedVisibleOrganizationIds("name", false);
 
   useEffect(() => {
     if (!selected) {
diff --git a/apps/desktop/src/contacts/new-person-form.tsx b/apps/desktop/src/contacts/new-person-form.tsx
index bdeb6f266a..656dcaeda0 100644
--- a/apps/desktop/src/contacts/new-person-form.tsx
+++ b/apps/desktop/src/contacts/new-person-form.tsx
@@ -1,7 +1,7 @@
 import { CornerDownLeft } from "lucide-react";
 import React, { useState } from "react";
 
-import * as main from "~/store/tinybase/store/main";
+import { useCreateHuman } from "~/contacts/hooks";
 
 export function NewPersonForm({
   onSave,
@@ -11,25 +11,7 @@ export function NewPersonForm({
   onCancel: () => void;
 }) {
   const [name, setName] = useState("");
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
-
-  const createHuman = main.UI.useSetRowCallback(
-    "humans",
-    (p: { name: string; humanId: string }) => p.humanId,
-    (p: { name: string; humanId: string }) => ({
-      user_id: userId || "",
-      created_at: new Date().toISOString(),
-      name: p.name,
-      email: "",
-      org_id: "",
-      job_title: "",
-      linkedin_username: "",
-      memo: "",
-      pinned: false,
-    }),
-    [userId],
-    main.STORE_ID,
-  );
+  const createHuman = useCreateHuman();
 
   const handleAdd = () => {
     const humanId = crypto.randomUUID();
diff --git a/apps/desktop/src/contacts/organization-details.tsx b/apps/desktop/src/contacts/organization-details.tsx
index b96b3487e7..f3f65f769f 100644
--- a/apps/desktop/src/contacts/organization-details.tsx
+++ b/apps/desktop/src/contacts/organization-details.tsx
@@ -9,7 +9,12 @@ import { cn } from "@hypr/utils";
 
 import { getContactBgClass } from "./shared";
 
-import * as main from "~/store/tinybase/store/main";
+import {
+  useOrganizationMembers,
+  useOrganization,
+  useOrganizationCell,
+  useUpdateOrganizationStringCell,
+} from "~/contacts/hooks";
 
 export function OrganizationDetailsColumn({
   selectedOrganizationId,
@@ -18,23 +23,12 @@ export function OrganizationDetailsColumn({
   selectedOrganizationId?: string | null;
   onPersonClick?: (personId: string) => void;
 }) {
-  const selectedOrgData = main.UI.useRow(
-    "organizations",
-    selectedOrganizationId ?? "",
-    main.STORE_ID,
-  );
-
-  const peopleInOrg = main.UI.useSliceRowIds(
-    main.INDEXES.humansByOrg,
-    selectedOrganizationId ?? "",
-    main.STORE_ID,
-  );
-
-  const allHumans = main.UI.useTable("humans", main.STORE_ID);
+  const selectedOrg = useOrganization(selectedOrganizationId);
+  const peopleInOrg = useOrganizationMembers(selectedOrganizationId);
 
   return (
     <div className="flex flex-1 flex-col">
-      {selectedOrgData && selectedOrganizationId ? (
+      {selectedOrg && selectedOrganizationId ? (
         <>
           <div className="flex items-center justify-center border-b border-neutral-200 py-6">
             <div className="flex h-16 w-16 items-center justify-center rounded-full bg-neutral-200">
@@ -66,11 +60,8 @@ export function OrganizationDetailsColumn({
               <div className="overflow-y-auto" style={{ maxHeight: "55vh" }}>
                 {(peopleInOrg?.length ?? 0) > 0 ? (
                   <div className="grid grid-cols-3 gap-4">
-                    {peopleInOrg.map((humanId: string) => {
-                      const human = allHumans[humanId];
-                      if (!human) {
-                        return null;
-                      }
+                    {peopleInOrg.map((human) => {
+                      const humanId = human.id;
 
                       return (
                         <div
@@ -83,22 +74,18 @@ export function OrganizationDetailsColumn({
                               className={cn([
                                 "shrink-0 rounded-full",
                                 getContactBgClass(
-                                  String(human.name || human.email || humanId),
+                                  human.name || human.email || humanId,
                                 ),
                               ])}
                             >
                               <Facehash
-                                name={String(
-                                  human.name || human.email || humanId,
-                                )}
+                                name={human.name || human.email || humanId}
                                 size={48}
                                 interactive={false}
                                 showInitial={false}
                                 colorClasses={[
                                   getContactBgClass(
-                                    String(
-                                      human.name || human.email || humanId,
-                                    ),
+                                    human.name || human.email || humanId,
                                   ),
                                 ]}
                               />
@@ -107,9 +94,9 @@ export function OrganizationDetailsColumn({
                               <div className="truncate text-sm font-semibold">
                                 {human.name || human.email || "Unnamed"}
                               </div>
-                              {human.job_title && (
+                              {human.jobTitle && (
                                 <div className="mt-1 truncate text-xs text-neutral-500">
-                                  {human.job_title as string}
+                                  {human.jobTitle}
                                 </div>
                               )}
                             </div>
@@ -130,15 +117,13 @@ export function OrganizationDetailsColumn({
                                   <Mail />
                                 </Button>
                               )}
-                              {human.linkedin_username && (
+                              {human.linkedinUsername && (
                                 <Button
                                   variant="ghost"
                                   size="icon"
                                   onClick={(e) => {
                                     e.stopPropagation();
-                                    const v = String(
-                                      human.linkedin_username ?? "",
-                                    );
+                                    const v = human.linkedinUsername;
                                     const href = /^https?:\/\//i.test(v)
                                       ? v
                                       : `https://www.linkedin.com/in/${v.replace(/^@/, "")}`;
@@ -182,25 +167,12 @@ function EditableOrganizationNameField({
 }: {
   organizationId: string;
 }) {
-  const value = main.UI.useCell(
-    "organizations",
-    organizationId,
-    "name",
-    main.STORE_ID,
-  );
-
-  const handleChange = main.UI.useSetCellCallback(
-    "organizations",
-    organizationId,
-    "name",
-    (e: React.ChangeEvent<HTMLInputElement>) => e.target.value,
-    [],
-    main.STORE_ID,
-  );
+  const value = useOrganizationCell(organizationId, "name");
+  const handleChange = useUpdateOrganizationStringCell(organizationId, "name");
 
   return (
     <Input
-      value={(value as string) || ""}
+      value={value}
       onChange={handleChange}
       placeholder="Organization name"
       className="h-7 border-none p-0 text-base shadow-none focus-visible:ring-0 focus-visible:ring-offset-0"
diff --git a/apps/desktop/src/contacts/organization-item.tsx b/apps/desktop/src/contacts/organization-item.tsx
index 271e061412..a82c10351f 100644
--- a/apps/desktop/src/contacts/organization-item.tsx
+++ b/apps/desktop/src/contacts/organization-item.tsx
@@ -3,8 +3,8 @@ import React, { useCallback } from "react";
 
 import { cn } from "@hypr/utils";
 
+import { useOrganization, useToggleOrganizationPin } from "~/contacts/hooks";
 import { useNativeContextMenu } from "~/shared/hooks/useNativeContextMenu";
-import * as main from "~/store/tinybase/store/main";
 
 export function OrganizationItem({
   organizationId,
@@ -17,44 +17,9 @@ export function OrganizationItem({
   onClick: () => void;
   onDelete?: (id: string) => void;
 }) {
-  const organization = main.UI.useRow(
-    "organizations",
-    organizationId,
-    main.STORE_ID,
-  );
-  const isPinned = Boolean(organization.pinned);
-  const store = main.UI.useStore(main.STORE_ID);
-
-  const togglePin = useCallback(() => {
-    if (!store) return;
-
-    const currentPinned = store.getCell(
-      "organizations",
-      organizationId,
-      "pinned",
-    );
-    if (currentPinned) {
-      store.setPartialRow("organizations", organizationId, {
-        pinned: false,
-        pin_order: 0,
-      });
-    } else {
-      const allOrgs = store.getTable("organizations");
-      const allHumans = store.getTable("humans");
-      const maxOrgOrder = Object.values(allOrgs).reduce((max, o) => {
-        const order = (o.pin_order as number | undefined) ?? 0;
-        return Math.max(max, order);
-      }, 0);
-      const maxHumanOrder = Object.values(allHumans).reduce((max, h) => {
-        const order = (h.pin_order as number | undefined) ?? 0;
-        return Math.max(max, order);
-      }, 0);
-      store.setPartialRow("organizations", organizationId, {
-        pinned: true,
-        pin_order: Math.max(maxOrgOrder, maxHumanOrder) + 1,
-      });
-    }
-  }, [store, organizationId]);
+  const organization = useOrganization(organizationId);
+  const isPinned = organization?.pinned ?? false;
+  const togglePin = useToggleOrganizationPin(organizationId);
 
   const showContextMenu = useNativeContextMenu([
     {
diff --git a/apps/desktop/src/contacts/person-item.tsx b/apps/desktop/src/contacts/person-item.tsx
index c78da5d6c8..a4d2446e47 100644
--- a/apps/desktop/src/contacts/person-item.tsx
+++ b/apps/desktop/src/contacts/person-item.tsx
@@ -4,9 +4,9 @@ import React, { useCallback } from "react";
 
 import { cn } from "@hypr/utils";
 
+import { useHuman, useToggleHumanPin } from "~/contacts/hooks";
 import { getContactBgClass } from "~/contacts/shared";
 import { useNativeContextMenu } from "~/shared/hooks/useNativeContextMenu";
-import * as main from "~/store/tinybase/store/main";
 
 export function PersonItem({
   humanId,
@@ -19,41 +19,14 @@ export function PersonItem({
   onClick: () => void;
   onDelete?: (id: string) => void;
 }) {
-  const person = main.UI.useRow("humans", humanId, main.STORE_ID);
-  const isPinned = Boolean(person.pinned);
-  const personName = String(person.name ?? "");
-  const personEmail = String(person.email ?? "");
+  const person = useHuman(humanId);
+  const isPinned = person?.pinned ?? false;
+  const personName = person?.name ?? "";
+  const personEmail = person?.email ?? "";
   const facehashName = personName || personEmail || humanId;
   const bgClass = getContactBgClass(facehashName);
 
-  const store = main.UI.useStore(main.STORE_ID);
-
-  const togglePin = useCallback(() => {
-    if (!store) return;
-
-    const currentPinned = store.getCell("humans", humanId, "pinned");
-    if (currentPinned) {
-      store.setPartialRow("humans", humanId, {
-        pinned: false,
-        pin_order: 0,
-      });
-    } else {
-      const allHumans = store.getTable("humans");
-      const allOrgs = store.getTable("organizations");
-      const maxHumanOrder = Object.values(allHumans).reduce((max, h) => {
-        const order = (h.pin_order as number | undefined) ?? 0;
-        return Math.max(max, order);
-      }, 0);
-      const maxOrgOrder = Object.values(allOrgs).reduce((max, o) => {
-        const order = (o.pin_order as number | undefined) ?? 0;
-        return Math.max(max, order);
-      }, 0);
-      store.setPartialRow("humans", humanId, {
-        pinned: true,
-        pin_order: Math.max(maxHumanOrder, maxOrgOrder) + 1,
-      });
-    }
-  }, [store, humanId]);
+  const togglePin = useToggleHumanPin(humanId);
 
   const showContextMenu = useNativeContextMenu([
     {
diff --git a/apps/desktop/src/edit/tab-content.tsx b/apps/desktop/src/edit/tab-content.tsx
index 080f9ce8a2..0228c59950 100644
--- a/apps/desktop/src/edit/tab-content.tsx
+++ b/apps/desktop/src/edit/tab-content.tsx
@@ -4,8 +4,8 @@ import { useCallback, useMemo } from "react";
 import { useStrictModeUnmount } from "./hooks";
 
 import { usePendingEditStore } from "~/chat/tools/pending-edit-store";
+import { useEditTabTitles } from "~/session/hooks/enhanced-notes";
 import { StandardTabWrapper } from "~/shared/main";
-import * as main from "~/store/tinybase/store/main";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
 
 type EditTab = Extract<Tab, { type: "edit" }>;
@@ -14,17 +14,12 @@ export function TabContentEdit({ tab }: { tab: EditTab }) {
   const edit = usePendingEditStore((s) => s.edits.get(tab.requestId));
   const resolveEdit = usePendingEditStore((s) => s.resolveEdit);
 
-  const store = main.UI.useStore(main.STORE_ID);
-  const sessionTitle = useMemo(() => {
-    if (!store || !edit) return null;
-    const title = store.getCell("sessions", edit.sessionId, "title");
-    return typeof title === "string" && title.trim() ? title : null;
-  }, [store, edit]);
-  const summaryTitle = useMemo(() => {
-    if (!store || !edit) return null;
-    const title = store.getCell("enhanced_notes", edit.enhancedNoteId, "title");
-    return typeof title === "string" && title.trim() ? title : null;
-  }, [store, edit]);
+  const titles = useEditTabTitles(
+    edit?.sessionId ?? "",
+    edit?.enhancedNoteId ?? "",
+  );
+  const sessionTitle = edit ? titles.sessionTitle : null;
+  const summaryTitle = edit ? titles.summaryTitle : null;
 
   const declineOnUnmount = useCallback(() => {
     const still = usePendingEditStore.getState().edits.get(tab.requestId);
diff --git a/apps/desktop/src/editor/node-views/session-view.test.tsx b/apps/desktop/src/editor/node-views/session-view.test.tsx
index 55bcab96eb..1cd98cb79f 100644
--- a/apps/desktop/src/editor/node-views/session-view.test.tsx
+++ b/apps/desktop/src/editor/node-views/session-view.test.tsx
@@ -32,6 +32,16 @@ vi.mock("~/store/tinybase/store/main", () => ({
         ended_at: "2026-04-06T01:00:00.000Z",
       }),
     }),
+    useCell: (_table: string, _rowId: string, field: string) => {
+      if (field === "created_at") return "2026-04-06T00:00:00.000Z";
+      if (field === "event_json") {
+        return JSON.stringify({
+          started_at: "2026-04-06T02:30:00.000Z",
+          ended_at: "2026-04-06T01:00:00.000Z",
+        });
+      }
+      return undefined;
+    },
   },
 }));
 
diff --git a/apps/desktop/src/editor/node-views/session-view.tsx b/apps/desktop/src/editor/node-views/session-view.tsx
index a30af38e80..0b0189028f 100644
--- a/apps/desktop/src/editor/node-views/session-view.tsx
+++ b/apps/desktop/src/editor/node-views/session-view.tsx
@@ -18,8 +18,8 @@ import { TaskCheckbox } from "./task-checkbox";
 
 import { toTz, useTimezone } from "~/calendar/hooks";
 import { useLinkedItemOpenBehavior } from "~/editor/session/linked-item-open-behavior";
+import { useSessionCell } from "~/session/hooks/sessions";
 import { getSessionEvent } from "~/session/utils";
-import * as main from "~/store/tinybase/store/main";
 import { useTabs } from "~/store/zustand/tabs";
 import { useListener } from "~/stt/contexts";
 
@@ -79,24 +79,28 @@ export const SessionNodeView = forwardRef<
   const { node, getPos } = nodeProps;
   const sessionId = node.attrs.sessionId as string;
 
-  const session = main.UI.useRow("sessions", sessionId, main.STORE_ID);
+  const eventJson = useSessionCell(sessionId, "event_json");
+  const createdAt = useSessionCell(sessionId, "created_at");
   const tz = useTimezone();
   const liveSessionId = useListener((state) => state.live.sessionId);
   const liveStatus = useListener((state) => state.live.status);
   const isRecording =
     liveSessionId === sessionId &&
     (liveStatus === "active" || liveStatus === "finalizing");
-  const event = useMemo(() => getSessionEvent(session), [session]);
+  const event = useMemo(
+    () => getSessionEvent({ event_json: eventJson }),
+    [eventJson],
+  );
   const displayTime = useMemo(() => {
     if (event?.is_all_day) {
       return null;
     }
 
-    const rawDate = event?.started_at ?? session?.created_at;
+    const rawDate = event?.started_at ?? createdAt;
     const parsed = rawDate ? safeParseDate(rawDate) : null;
 
     return parsed ? format(toTz(parsed, tz), "h:mm a") : null;
-  }, [event?.is_all_day, event?.started_at, session?.created_at, tz]);
+  }, [event?.is_all_day, event?.started_at, createdAt, tz]);
 
   const isMeetingOver = useMemo(() => {
     if (!event?.ended_at) return false;
diff --git a/apps/desktop/src/editor/node-views/task-item-view.test.tsx b/apps/desktop/src/editor/node-views/task-item-view.test.tsx
index bb5314e595..73df4e1ff1 100644
--- a/apps/desktop/src/editor/node-views/task-item-view.test.tsx
+++ b/apps/desktop/src/editor/node-views/task-item-view.test.tsx
@@ -26,7 +26,7 @@ vi.mock("../task-source", () => ({
   useTaskSourceOptional: () => null,
 }));
 
-vi.mock("../task-storage", () => ({
+vi.mock("~/tasks/hooks", () => ({
   useTaskRecord: () => null,
   useTaskStorageOptional: () => null,
 }));
diff --git a/apps/desktop/src/editor/node-views/task-item-view.tsx b/apps/desktop/src/editor/node-views/task-item-view.tsx
index ad83a51384..df38350258 100644
--- a/apps/desktop/src/editor/node-views/task-item-view.tsx
+++ b/apps/desktop/src/editor/node-views/task-item-view.tsx
@@ -9,7 +9,6 @@ import { forwardRef, type ReactNode, useMemo, useState } from "react";
 import { cn, format, parseISO } from "@hypr/utils";
 
 import { useTaskSourceOptional } from "../task-source";
-import { useTaskRecord, useTaskStorageOptional } from "../task-storage";
 import {
   createTaskStatusAttrs,
   getNextTaskStatus,
@@ -17,6 +16,8 @@ import {
 } from "../tasks";
 import { TaskCheckbox } from "./task-checkbox";
 
+import { useTaskRecord, useTaskStorageOptional } from "~/tasks/hooks";
+
 export const taskListNodeSpec: NodeSpec = {
   content: "taskItem+",
   group: "block",
diff --git a/apps/desktop/src/editor/session/index.tsx b/apps/desktop/src/editor/session/index.tsx
index bce1fe6ff6..3c86a7b734 100644
--- a/apps/desktop/src/editor/session/index.tsx
+++ b/apps/desktop/src/editor/session/index.tsx
@@ -58,7 +58,6 @@ import {
   taskIdentityPlugin,
 } from "../plugins";
 import { TaskSourceProvider } from "../task-source";
-import { useTaskStorageOptional } from "../task-storage";
 import {
   extractTasksFromContent,
   hydrateTaskContent,
@@ -79,6 +78,8 @@ import {
 } from "./linked-item-open-behavior";
 import { schema } from "./schema";
 
+import { useTaskStorageOptional } from "~/tasks/hooks";
+
 export type { MentionConfig, FileHandlerConfig, PlaceholderFunction };
 export { schema };
 
diff --git a/apps/desktop/src/editor/tasks.test.ts b/apps/desktop/src/editor/tasks.test.ts
index a93d0ceeef..4c978f819b 100644
--- a/apps/desktop/src/editor/tasks.test.ts
+++ b/apps/desktop/src/editor/tasks.test.ts
@@ -1,6 +1,5 @@
 import { describe, expect, it } from "vitest";
 
-import { createInMemoryTaskStorage } from "./task-storage";
 import {
   createTaskItemNode,
   extractTasksFromContent,
@@ -9,6 +8,8 @@ import {
   normalizeTaskContent,
 } from "./tasks";
 
+import { createInMemoryTaskStorage } from "~/tasks/hooks";
+
 describe("task content", () => {
   it("assigns unique task ids and task item ids to missing and duplicated task items", () => {
     const content = normalizeTaskContent({
diff --git a/apps/desktop/src/folders/index.tsx b/apps/desktop/src/folders/index.tsx
index 39724a24f3..f8c74128fc 100644
--- a/apps/desktop/src/folders/index.tsx
+++ b/apps/desktop/src/folders/index.tsx
@@ -7,55 +7,22 @@ import { cn } from "@hypr/utils";
 import { Section } from "./shared";
 
 import { useBillingAccess } from "~/auth/billing";
+import {
+  useSessionFolderTree,
+  useSession,
+  useSessionIdsInFolder,
+} from "~/session/hooks/sessions";
 import { StandardTabWrapper } from "~/shared/main";
 import { type TabItem, TabItemBase } from "~/shared/tabs";
 import {
   FolderBreadcrumb,
   useFolderChain,
 } from "~/shared/ui/folder-breadcrumb";
-import { useSession } from "~/store/tinybase/hooks";
 import { sessionOps } from "~/store/tinybase/persister/session/ops";
-import * as main from "~/store/tinybase/store/main";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
 
 function useFolderTree() {
-  const sessionIds = main.UI.useRowIds("sessions", main.STORE_ID);
-  const store = main.UI.useStore(main.STORE_ID);
-
-  return useMemo(() => {
-    if (!store || !sessionIds)
-      return {
-        topLevel: [] as string[],
-        byParent: {} as Record<string, string[]>,
-      };
-
-    const allFolders = new Set<string>();
-    for (const id of sessionIds) {
-      const folderId = store.getCell("sessions", id, "folder_id") as string;
-      if (folderId) {
-        const parts = folderId.split("/");
-        for (let i = 1; i <= parts.length; i++) {
-          allFolders.add(parts.slice(0, i).join("/"));
-        }
-      }
-    }
-
-    const topLevel: string[] = [];
-    const byParent: Record<string, string[]> = {};
-
-    for (const folder of allFolders) {
-      const parts = folder.split("/");
-      if (parts.length === 1) {
-        topLevel.push(folder);
-      } else {
-        const parent = parts.slice(0, -1).join("/");
-        byParent[parent] = byParent[parent] || [];
-        byParent[parent].push(folder);
-      }
-    }
-
-    return { topLevel: topLevel.sort(), byParent };
-  }, [sessionIds, store]);
+  return useSessionFolderTree();
 }
 
 function useFolderName(folderId: string) {
@@ -219,11 +186,7 @@ function FolderCard({ folderId }: { folderId: string }) {
 
   const childFolderIds = byParent[folderId] || [];
 
-  const sessionIds = main.UI.useSliceRowIds(
-    main.INDEXES.sessionsByFolder,
-    folderId,
-    main.STORE_ID,
-  );
+  const sessionIds = useSessionIdsInFolder(folderId);
 
   const childCount = childFolderIds.length + (sessionIds?.length ?? 0);
 
@@ -313,11 +276,7 @@ function TabContentFolderSpecific({ folderId }: { folderId: string }) {
   const { byParent } = useFolderTree();
   const childFolderIds = byParent[folderId] || [];
 
-  const sessionIds = main.UI.useSliceRowIds(
-    main.INDEXES.sessionsByFolder,
-    folderId,
-    main.STORE_ID,
-  );
+  const sessionIds = useSessionIdsInFolder(folderId);
 
   const isEmpty =
     childFolderIds.length === 0 && (sessionIds?.length ?? 0) === 0;
diff --git a/apps/desktop/src/main/layout.tsx b/apps/desktop/src/main/layout.tsx
index 27b041cd6b..4ae0cab8da 100644
--- a/apps/desktop/src/main/layout.tsx
+++ b/apps/desktop/src/main/layout.tsx
@@ -6,9 +6,9 @@ import { AITaskProvider } from "~/ai/contexts";
 import { NotificationProvider } from "~/contexts/notifications";
 import { ShellProvider } from "~/contexts/shell";
 import { ToolRegistryProvider } from "~/contexts/tool";
-import { TaskStorageProvider } from "~/editor/task-storage";
 import { SearchEngineProvider } from "~/search/contexts/engine";
 import { SearchUIProvider } from "~/search/contexts/ui";
+import { TaskStorageProvider } from "~/tasks/hooks";
 
 export function ClassicMainLayout({
   children,
diff --git a/apps/desktop/src/main/lifecycle.tsx b/apps/desktop/src/main/lifecycle.tsx
index 17361d45f6..031e7e6b70 100644
--- a/apps/desktop/src/main/lifecycle.tsx
+++ b/apps/desktop/src/main/lifecycle.tsx
@@ -7,24 +7,25 @@ import { buildChatTools } from "~/chat/tools";
 import { useRegisterTools } from "~/contexts/tool";
 import { useSearchEngine } from "~/search/contexts/engine";
 import { initEnhancerService } from "~/services/enhancer";
-import { getSessionEvent } from "~/session/utils";
-import { useDesktopTabLifecycle } from "~/shared/desktop-tab-lifecycle";
-import * as main from "~/store/tinybase/store/main";
+import { useSummaryEditRuntime } from "~/session/hooks/enhanced-notes";
+import { useEnhancerSessionIndex } from "~/session/hooks/runtime";
+import {
+  useCalendarEventSearchIndex,
+  useContactSearchIndex,
+  useSessionSearchTimestampLookup,
+} from "~/session/hooks/search";
+import { useSessionTabLifecycle } from "~/session/hooks/sessions";
 import * as settings from "~/store/tinybase/store/settings";
 import { useTabs } from "~/store/zustand/tabs";
 
 export function useClassicMainLifecycle() {
   const openNew = useTabs((state) => state.openNew);
-  const store = main.UI.useStore(main.STORE_ID);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
 
   const openDefaultEmptyTab = useCallback(() => {
     openNew({ type: "empty" });
   }, [openNew]);
 
-  useDesktopTabLifecycle({
-    store,
-    indexes,
+  useSessionTabLifecycle({
     onEmpty: openDefaultEmptyTab,
     onZeroTabs: openDefaultEmptyTab,
   });
@@ -41,196 +42,11 @@ export function ClassicMainServices() {
 
 function ToolRegistration() {
   const { search } = useSearchEngine();
-  const store = main.UI.useStore(main.STORE_ID);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
-  const storeRef = useRef(store);
-  storeRef.current = store;
-  const indexesRef = useRef(indexes);
-  indexesRef.current = indexes;
-
-  const getContactSearchResults = useCallback(
-    async (query: string, limit: number) => {
-      if (!store) {
-        return [];
-      }
-
-      const q = query.trim().toLowerCase();
-      const rows: Array<{
-        id: string;
-        name: string;
-        email: string | null;
-        jobTitle: string | null;
-        organization: string | null;
-        memo: string | null;
-        createdAt: number;
-      }> = [];
-
-      store.forEachRow("humans", (rowId, _forEachCell) => {
-        const row = store.getRow("humans", rowId);
-        if (!row) {
-          return;
-        }
-
-        const orgId =
-          typeof row.org_id === "string" && row.org_id ? row.org_id : null;
-        const orgName = orgId
-          ? (store.getCell("organizations", orgId, "name") as string | null)
-          : null;
-
-        const name = typeof row.name === "string" ? row.name : "";
-        const email =
-          typeof row.email === "string" && row.email ? row.email : null;
-        const jobTitle =
-          typeof row.job_title === "string" && row.job_title
-            ? row.job_title
-            : null;
-        const memo = typeof row.memo === "string" && row.memo ? row.memo : null;
-
-        const searchable = [name, email, jobTitle, memo, orgName]
-          .filter(Boolean)
-          .join("\n")
-          .toLowerCase();
-
-        if (q && !searchable.includes(q)) {
-          return;
-        }
-
-        const createdAt = Date.parse((row.created_at as string) || "") || 0;
-
-        rows.push({
-          id: rowId,
-          name,
-          email,
-          jobTitle,
-          organization: orgName,
-          memo,
-          createdAt,
-        });
-      });
-
-      rows.sort((a, b) => b.createdAt - a.createdAt);
-
-      return rows
-        .slice(0, limit)
-        .map(({ createdAt: _createdAt, ...row }) => row);
-    },
-    [store],
-  );
-
-  const getCalendarEventSearchResults = useCallback(
-    async (query: string, limit: number) => {
-      if (!store) {
-        return [];
-      }
-
-      const q = query.trim().toLowerCase();
-      const sessionByTrackingId = new Map<string, string>();
-
-      store.forEachRow("sessions", (sessionId, _forEachCell) => {
-        const row = store.getRow("sessions", sessionId);
-        if (!row) {
-          return;
-        }
-
-        const event = getSessionEvent({
-          event_json:
-            typeof row.event_json === "string" ? row.event_json : undefined,
-        });
-        if (!event?.tracking_id) {
-          return;
-        }
-        sessionByTrackingId.set(event.tracking_id, sessionId);
-      });
-
-      const rows: Array<{
-        id: string;
-        title: string;
-        startedAt: string | null;
-        endedAt: string | null;
-        location: string | null;
-        meetingLink: string | null;
-        description: string | null;
-        participantCount: number;
-        linkedSessionId: string | null;
-        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
-            : "";
-
-        let participantCount = 0;
-        if (
-          typeof row.participants_json === "string" &&
-          row.participants_json
-        ) {
-          try {
-            const parsed = JSON.parse(row.participants_json);
-            if (Array.isArray(parsed)) {
-              participantCount = parsed.length;
-            }
-          } catch {}
-        }
-
-        const searchable = [title, location, meetingLink, description]
-          .filter(Boolean)
-          .join("\n")
-          .toLowerCase();
-
-        if (q && !searchable.includes(q)) {
-          return;
-        }
-
-        rows.push({
-          id: eventId,
-          title: title || "Untitled event",
-          startedAt,
-          endedAt,
-          location,
-          meetingLink,
-          description,
-          participantCount,
-          linkedSessionId: sessionByTrackingId.get(trackingId) ?? null,
-          startedAtMs: startedAt ? Date.parse(startedAt) || 0 : 0,
-        });
-      });
-
-      rows.sort((a, b) => b.startedAtMs - a.startedAtMs);
-
-      return rows
-        .slice(0, limit)
-        .map(({ startedAtMs: _startedAtMs, ...row }) => row);
-    },
-    [store],
-  );
+  const getContactSearchResults = useContactSearchIndex();
+  const getCalendarEventSearchResults = useCalendarEventSearchIndex();
+  const getSessionSearchTimestamp = useSessionSearchTimestampLookup();
+  const { getSummaryCandidates, getSummaryMarkdown, applySummaryMarkdown } =
+    useSummaryEditRuntime();
 
   const { getSessionId, getEnhancedNoteId } = useSessionTab();
   const openEditTab = useCallback((requestId: string) => {
@@ -244,8 +60,10 @@ function ToolRegistration() {
         search,
         getContactSearchResults,
         getCalendarEventSearchResults,
-        getStore: () => storeRef.current ?? undefined,
-        getIndexes: () => indexesRef.current ?? undefined,
+        getSessionSearchTimestamp,
+        getSummaryCandidates,
+        getSummaryMarkdown,
+        applySummaryMarkdown,
         getSessionId,
         getEnhancedNoteId,
         openEditTab,
@@ -254,6 +72,10 @@ function ToolRegistration() {
       search,
       getContactSearchResults,
       getCalendarEventSearchResults,
+      getSessionSearchTimestamp,
+      getSummaryCandidates,
+      getSummaryMarkdown,
+      applySummaryMarkdown,
       getSessionId,
       getEnhancedNoteId,
       openEditTab,
@@ -270,7 +92,7 @@ function EnhancerInit() {
 
   const model = useLanguageModel("enhance");
   const { conn: llmConn } = useLLMConnection();
-  const indexes = main.UI.useIndexes(main.STORE_ID);
+  const childIndex = useEnhancerSessionIndex();
   const selectedTemplateId = settings.UI.useValue(
     "selected_template_id",
     settings.STORE_ID,
@@ -284,11 +106,11 @@ function EnhancerInit() {
   templateIdRef.current = selectedTemplateId;
 
   useEffect(() => {
-    if (!persistedStore || !aiTaskStore || !indexes) return;
+    if (!persistedStore || !aiTaskStore || !childIndex) return;
 
     const service = initEnhancerService({
       mainStore: persistedStore,
-      indexes,
+      childIndex,
       aiTaskStore,
       getModel: () => modelRef.current,
       getLLMConn: () => llmConnRef.current,
@@ -296,7 +118,7 @@ function EnhancerInit() {
     });
 
     return () => service.dispose();
-  }, [persistedStore, aiTaskStore, indexes]);
+  }, [persistedStore, aiTaskStore, childIndex]);
 
   return null;
 }
diff --git a/apps/desktop/src/main2/home/note-editor-runtime.ts b/apps/desktop/src/main2/home/note-editor-runtime.ts
new file mode 100644
index 0000000000..f52ebdc73c
--- /dev/null
+++ b/apps/desktop/src/main2/home/note-editor-runtime.ts
@@ -0,0 +1,338 @@
+import { Node as PMNode } from "prosemirror-model";
+import type { EditorView } from "prosemirror-view";
+import { useCallback, useMemo } from "react";
+
+import { parseJsonContent } from "~/editor/markdown";
+import { type JSONContent, schema } from "~/editor/session";
+import {
+  getNodeTextContent,
+  mergeLinkedSessionsIntoContent,
+} from "~/editor/session/linked-session-content";
+import {
+  extractTasksFromContent,
+  hydrateTaskContent,
+  moveOpenTasksBetweenContents,
+  normalizeTaskContent,
+  type TaskSource,
+} from "~/editor/tasks";
+import { useUpdateDailyNoteContent } from "~/session/hooks/daily-notes";
+import { type MainStore, useMainStoreInternal } from "~/session/hooks/internal";
+import {
+  findSessionByEventId,
+  findSessionByTrackingId,
+  getSessionEventById,
+} from "~/session/utils";
+import { getOrCreateSessionForEventId } from "~/store/tinybase/store/sessions";
+import type { TaskStorage } from "~/tasks/hooks";
+
+type Store = MainStore;
+const emptyDoc: JSONContent = { type: "doc", content: [{ type: "paragraph" }] };
+
+function getSessionTitle(store: Store, sessionId: string): string {
+  const title = store.getCell("sessions", sessionId, "title");
+  return typeof title === "string" ? title : "";
+}
+
+function resolveEventSessionId(
+  store: Store,
+  eventId: string,
+  createMissing = false,
+): string | null {
+  const existingSessionId = findSessionByEventId(store, eventId);
+  if (existingSessionId) {
+    return existingSessionId;
+  }
+
+  const event = store.getRow("events", eventId);
+  if (!event) {
+    return null;
+  }
+
+  return createMissing
+    ? getOrCreateSessionForEventId(store, eventId, event.title as string)
+    : null;
+}
+
+function normalizeSessionId(store: Store, sessionId: string): string {
+  const trackingId = getSessionEventById(store, sessionId)?.tracking_id;
+  if (!trackingId) {
+    return sessionId;
+  }
+
+  return findSessionByTrackingId(store, trackingId) ?? sessionId;
+}
+
+function buildLinkedSessionIds(
+  store: Store,
+  eventIds: string[],
+  sessionIds: string[],
+): string[] {
+  const linkedSessionIds: string[] = [];
+  const seenSessionIds = new Set<string>();
+
+  const pushSessionId = (sessionId: string | null) => {
+    if (!sessionId) {
+      return;
+    }
+
+    const normalizedSessionId = normalizeSessionId(store, sessionId);
+    if (!normalizedSessionId || seenSessionIds.has(normalizedSessionId)) {
+      return;
+    }
+
+    seenSessionIds.add(normalizedSessionId);
+    linkedSessionIds.push(normalizedSessionId);
+  };
+
+  for (const eventId of eventIds) {
+    pushSessionId(resolveEventSessionId(store, eventId));
+  }
+
+  for (const sessionId of sessionIds) {
+    pushSessionId(sessionId);
+  }
+
+  return linkedSessionIds;
+}
+
+function buildLinkedContent(
+  store: Store,
+  content: JSONContent,
+  eventIds: string[],
+  sessionIds: string[],
+): JSONContent {
+  const linkedSessionIds = buildLinkedSessionIds(store, eventIds, sessionIds);
+  const linkedSessionIdSet = new Set(linkedSessionIds);
+
+  return mergeLinkedSessionsIntoContent({
+    content,
+    eventIds,
+    sessionIds,
+    resolveEventSessionId: (eventId) => resolveEventSessionId(store, eventId),
+    getSessionTitle: (sessionId) => getSessionTitle(store, sessionId),
+    normalizeSessionId: (sessionId) => normalizeSessionId(store, sessionId),
+    keepLinkedSession: (sessionId) => linkedSessionIdSet.has(sessionId),
+  });
+}
+
+function readRawContent(store: Store, date: string): JSONContent {
+  const cell = store.getCell("daily_notes", date, "content");
+  return normalizeTaskContent(parseJsonContent(cell as string)) ?? emptyDoc;
+}
+
+function syncLinkedSessions(
+  view: EditorView,
+  store: Store,
+  eventIds: string[],
+  sessionIds: string[],
+): boolean {
+  for (const eventId of eventIds) {
+    resolveEventSessionId(store, eventId, true);
+  }
+
+  const currentContent = view.state.doc.toJSON() as JSONContent;
+  const nextContent = buildLinkedContent(
+    store,
+    currentContent,
+    eventIds,
+    sessionIds,
+  );
+  if (JSON.stringify(nextContent) === JSON.stringify(currentContent)) {
+    return false;
+  }
+
+  const nextDoc = PMNode.fromJSON(schema, nextContent);
+  if (nextDoc.eq(view.state.doc)) {
+    return false;
+  }
+
+  view.dispatch(
+    view.state.tr.replaceWith(0, view.state.doc.content.size, nextDoc.content),
+  );
+  return true;
+}
+
+export function useDailyNoteEditorRuntime(date: string): {
+  initializeContent: (args: {
+    isToday?: boolean;
+    previousDate: string;
+    eventIds: string[];
+    sessionIds: string[];
+    taskStorage: TaskStorage | null;
+    taskSource: TaskSource;
+    previousTaskSource: TaskSource;
+  }) => JSONContent | null;
+  syncLinkedSessionsInView: (
+    view: EditorView,
+    eventIds: string[],
+    sessionIds: string[],
+  ) => void;
+  syncSessionNodeTitles: (input: JSONContent) => void;
+  persistDailyNote: (input: JSONContent) => void;
+} {
+  const store = useMainStoreInternal();
+  const updateDailyNoteContent = useUpdateDailyNoteContent(date);
+
+  const initializeContent = useCallback(
+    ({
+      isToday,
+      previousDate,
+      eventIds,
+      sessionIds,
+      taskStorage,
+      taskSource,
+      previousTaskSource,
+    }: {
+      isToday?: boolean;
+      previousDate: string;
+      eventIds: string[];
+      sessionIds: string[];
+      taskStorage: TaskStorage | null;
+      taskSource: TaskSource;
+      previousTaskSource: TaskSource;
+    }) => {
+      if (!store) return null;
+
+      for (const eventId of eventIds) {
+        resolveEventSessionId(store, eventId, 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),
+            });
+          }
+        } 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),
+        });
+      }
+
+      return content;
+    },
+    [date, store],
+  );
+
+  const syncLinkedSessionsInView = useCallback(
+    (view: EditorView, eventIds: string[], sessionIds: string[]) => {
+      if (!store) return;
+      syncLinkedSessions(view, store, eventIds, sessionIds);
+    },
+    [store],
+  );
+
+  const syncSessionNodeTitles = useCallback(
+    (input: JSONContent) => {
+      if (!store) return;
+
+      for (const node of input.content ?? []) {
+        if (node.type !== "session") {
+          continue;
+        }
+
+        const sessionId = node.attrs?.sessionId;
+        if (typeof sessionId !== "string" || sessionId === "") {
+          continue;
+        }
+
+        const nextTitle = getNodeTextContent(node);
+        const currentTitle = getSessionTitle(store, sessionId);
+        if (nextTitle !== currentTitle) {
+          store.setPartialRow("sessions", sessionId, { title: nextTitle });
+        }
+      }
+    },
+    [store],
+  );
+
+  const persistDailyNote = useCallback(
+    (input: JSONContent) => updateDailyNoteContent(JSON.stringify(input)),
+    [updateDailyNoteContent],
+  );
+
+  return useMemo(
+    () => ({
+      initializeContent,
+      syncLinkedSessionsInView,
+      syncSessionNodeTitles,
+      persistDailyNote,
+    }),
+    [
+      initializeContent,
+      syncLinkedSessionsInView,
+      syncSessionNodeTitles,
+      persistDailyNote,
+    ],
+  );
+}
diff --git a/apps/desktop/src/main2/home/note-editor.tsx b/apps/desktop/src/main2/home/note-editor.tsx
index e77b42fbbe..9ed2416bd6 100644
--- a/apps/desktop/src/main2/home/note-editor.tsx
+++ b/apps/desktop/src/main2/home/note-editor.tsx
@@ -1,164 +1,18 @@
 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 { format, parseISO, subDays } from "@hypr/utils";
 
+import { useDailyNoteEditorRuntime } from "./note-editor-runtime";
+
 import { useCalendarData } from "~/calendar/hooks";
-import { parseJsonContent } from "~/editor/markdown";
 import {
   type JSONContent,
   NoteEditor,
   type NoteEditorRef,
-  schema,
 } from "~/editor/session";
-import {
-  getNodeTextContent,
-  mergeLinkedSessionsIntoContent,
-} from "~/editor/session/linked-session-content";
-import { useTaskStorageOptional } from "~/editor/task-storage";
-import {
-  extractTasksFromContent,
-  hydrateTaskContent,
-  moveOpenTasksBetweenContents,
-  normalizeTaskContent,
-} from "~/editor/tasks";
-import {
-  findSessionByEventId,
-  findSessionByTrackingId,
-  getSessionEventById,
-} from "~/session/utils";
-import * as main from "~/store/tinybase/store/main";
-import { getOrCreateSessionForEventId } from "~/store/tinybase/store/sessions";
-
-type Store = NonNullable<ReturnType<typeof main.UI.useStore>>;
-const emptyDoc: JSONContent = { type: "doc", content: [{ type: "paragraph" }] };
-
-function getSessionTitle(store: Store, sessionId: string): string {
-  const title = store.getCell("sessions", sessionId, "title");
-  return typeof title === "string" ? title : "";
-}
-
-function resolveEventSessionId(
-  store: Store,
-  eventId: string,
-  createMissing = false,
-): string | null {
-  const existingSessionId = findSessionByEventId(store, eventId);
-  if (existingSessionId) {
-    return existingSessionId;
-  }
-
-  const event = store.getRow("events", eventId);
-  if (!event) {
-    return null;
-  }
-
-  return createMissing
-    ? getOrCreateSessionForEventId(store, eventId, event.title as string)
-    : null;
-}
-
-function normalizeSessionId(store: Store, sessionId: string): string {
-  const trackingId = getSessionEventById(store, sessionId)?.tracking_id;
-  if (!trackingId) {
-    return sessionId;
-  }
-
-  return findSessionByTrackingId(store, trackingId) ?? sessionId;
-}
-
-function buildLinkedSessionIds(
-  store: Store,
-  eventIds: string[],
-  sessionIds: string[],
-): string[] {
-  const linkedSessionIds: string[] = [];
-  const seenSessionIds = new Set<string>();
-
-  const pushSessionId = (sessionId: string | null) => {
-    if (!sessionId) {
-      return;
-    }
-
-    const normalizedSessionId = normalizeSessionId(store, sessionId);
-    if (!normalizedSessionId || seenSessionIds.has(normalizedSessionId)) {
-      return;
-    }
-
-    seenSessionIds.add(normalizedSessionId);
-    linkedSessionIds.push(normalizedSessionId);
-  };
-
-  for (const eventId of eventIds) {
-    pushSessionId(resolveEventSessionId(store, eventId));
-  }
-
-  for (const sessionId of sessionIds) {
-    pushSessionId(sessionId);
-  }
-
-  return linkedSessionIds;
-}
-
-function buildLinkedContent(
-  store: Store,
-  content: JSONContent,
-  eventIds: string[],
-  sessionIds: string[],
-): JSONContent {
-  const linkedSessionIds = buildLinkedSessionIds(store, eventIds, sessionIds);
-  const linkedSessionIdSet = new Set(linkedSessionIds);
-
-  return mergeLinkedSessionsIntoContent({
-    content,
-    eventIds,
-    sessionIds,
-    resolveEventSessionId: (eventId) => resolveEventSessionId(store, eventId),
-    getSessionTitle: (sessionId) => getSessionTitle(store, sessionId),
-    normalizeSessionId: (sessionId) => normalizeSessionId(store, sessionId),
-    keepLinkedSession: (sessionId) => linkedSessionIdSet.has(sessionId),
-  });
-}
-
-function syncLinkedSessions(
-  view: EditorView,
-  store: Store,
-  eventIds: string[],
-  sessionIds: string[],
-): boolean {
-  for (const eventId of eventIds) {
-    resolveEventSessionId(store, eventId, true);
-  }
-
-  const currentContent = view.state.doc.toJSON() as JSONContent;
-  const nextContent = buildLinkedContent(
-    store,
-    currentContent,
-    eventIds,
-    sessionIds,
-  );
-  if (JSON.stringify(nextContent) === JSON.stringify(currentContent)) {
-    return false;
-  }
-
-  const nextDoc = PMNode.fromJSON(schema, nextContent);
-  if (nextDoc.eq(view.state.doc)) {
-    return false;
-  }
-
-  view.dispatch(
-    view.state.tr.replaceWith(0, view.state.doc.content.size, nextDoc.content),
-  );
-  return true;
-}
-
-function readRawContent(store: Store, date: string): JSONContent {
-  const cell = store.getCell("daily_notes", date, "content");
-  return normalizeTaskContent(parseJsonContent(cell as string)) ?? emptyDoc;
-}
+import { useTaskStorageOptional } from "~/tasks/hooks";
 
 function isEditorTarget(target: EventTarget | null): boolean {
   return (
@@ -173,7 +27,7 @@ export function DailyNoteEditor({
   date: string;
   isToday?: boolean;
 }) {
-  const store = main.UI.useStore(main.STORE_ID);
+  const dailyNoteRuntime = useDailyNoteEditorRuntime(date);
   const editorRef = useRef<NoteEditorRef>(null);
   const taskStorage = useTaskStorageOptional();
   const taskSource = useMemo(() => ({ type: "daily_note", id: date }), [date]);
@@ -193,133 +47,37 @@ export function DailyNoteEditor({
   // Compute initial content once on mount — imperative read, no subscription.
   // 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 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),
-          });
-        }
-      } 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),
-      });
-    }
-
-    initialContentRef.current = content;
+  if (!initialContentRef.current) {
+    initialContentRef.current = dailyNoteRuntime.initializeContent({
+      isToday,
+      previousDate,
+      eventIds,
+      sessionIds,
+      taskStorage,
+      taskSource,
+      previousTaskSource,
+    });
   }
 
-  const persistDailyNote = main.UI.useSetPartialRowCallback(
-    "daily_notes",
-    date,
-    (input: JSONContent) => ({ content: JSON.stringify(input), date }),
-    [date],
-    main.STORE_ID,
-  );
-
   useEffect(() => {
     const view = editorRef.current?.view;
-    if (!store || !view) {
+    if (!view) {
       return;
     }
 
     try {
-      syncLinkedSessions(view, store, eventIds, sessionIds);
+      dailyNoteRuntime.syncLinkedSessionsInView(view, eventIds, sessionIds);
     } catch {
       // invalid content
     }
-  }, [eventIds, sessionIds, store]);
+  }, [dailyNoteRuntime, eventIds, sessionIds]);
 
   const handleChange = useCallback(
     (input: JSONContent) => {
-      if (store) {
-        for (const node of input.content ?? []) {
-          if (node.type !== "session") {
-            continue;
-          }
-
-          const sessionId = node.attrs?.sessionId;
-          if (typeof sessionId !== "string" || sessionId === "") {
-            continue;
-          }
-
-          const nextTitle = getNodeTextContent(node);
-          const currentTitle = getSessionTitle(store, sessionId);
-          if (nextTitle !== currentTitle) {
-            store.setPartialRow("sessions", sessionId, { title: nextTitle });
-          }
-        }
-      }
-
-      persistDailyNote(input);
+      dailyNoteRuntime.syncSessionNodeTitles(input);
+      dailyNoteRuntime.persistDailyNote(input);
     },
-    [persistDailyNote, store],
+    [dailyNoteRuntime],
   );
 
   const focusEditor = useCallback(() => {
diff --git a/apps/desktop/src/main2/layout.tsx b/apps/desktop/src/main2/layout.tsx
index 134b3582c9..9980be52e5 100644
--- a/apps/desktop/src/main2/layout.tsx
+++ b/apps/desktop/src/main2/layout.tsx
@@ -4,10 +4,10 @@ import { AITaskProvider } from "~/ai/contexts";
 import { NotificationProvider } from "~/contexts/notifications";
 import { ShellProvider } from "~/contexts/shell";
 import { ToolRegistryProvider } from "~/contexts/tool";
-import { TaskStorageProvider } from "~/editor/task-storage";
 import { ClassicMainServices } from "~/main/lifecycle";
 import { SearchEngineProvider } from "~/search/contexts/engine";
 import { SearchUIProvider } from "~/search/contexts/ui";
+import { TaskStorageProvider } from "~/tasks/hooks";
 
 export function Main2Layout({ children }: { children: React.ReactNode }) {
   const { persistedStore, aiTaskStore, toolRegistry } = useRouteContext({
diff --git a/apps/desktop/src/main2/lifecycle.tsx b/apps/desktop/src/main2/lifecycle.tsx
index 4b3c39bdb1..e3d727f142 100644
--- a/apps/desktop/src/main2/lifecycle.tsx
+++ b/apps/desktop/src/main2/lifecycle.tsx
@@ -1,13 +1,7 @@
-import { useDesktopTabLifecycle } from "~/shared/desktop-tab-lifecycle";
-import * as main from "~/store/tinybase/store/main";
+import { useSessionTabLifecycle } from "~/session/hooks/sessions";
 
 export function useMain2Lifecycle() {
-  const store = main.UI.useStore(main.STORE_ID);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
-
-  useDesktopTabLifecycle({
-    store,
-    indexes,
+  useSessionTabLifecycle({
     onEmpty: null,
     onZeroTabs: null,
   });
diff --git a/apps/desktop/src/main2/profile-menu.tsx b/apps/desktop/src/main2/profile-menu.tsx
index e2d60fc0d1..238ea665fa 100644
--- a/apps/desktop/src/main2/profile-menu.tsx
+++ b/apps/desktop/src/main2/profile-menu.tsx
@@ -15,10 +15,11 @@ import { cn } from "@hypr/utils";
 
 import { useAuth } from "~/auth";
 import { useBillingAccess } from "~/auth/billing";
+import { useHumanCell } from "~/contacts/hooks";
+import { useCurrentUserId } from "~/session/hooks/globals";
 import { useAutoCloser } from "~/shared/hooks/useAutoCloser";
 import { AuthSection } from "~/sidebar/profile/auth";
 import { MenuItem, ProfileFacehash } from "~/sidebar/profile/shared";
-import * as main from "~/store/tinybase/store/main";
 import { useTabs } from "~/store/zustand/tabs";
 
 export function ProfileMenu() {
@@ -136,8 +137,8 @@ export function ProfileMenu() {
 function ProfileName() {
   const auth = useAuth();
   const { plan } = useBillingAccess();
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
-  const name = main.UI.useCell("humans", userId ?? "", "name", main.STORE_ID);
+  const userId = useCurrentUserId();
+  const name = useHumanCell(userId ?? "", "name");
   const displayName = name || auth?.session?.user.email || "Unknown";
 
   const facehashName = displayName;
@@ -176,8 +177,8 @@ function AvatarButton({
   onClick: () => void;
 }) {
   const auth = useAuth();
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
-  const name = main.UI.useCell("humans", userId ?? "", "name", main.STORE_ID);
+  const userId = useCurrentUserId();
+  const name = useHumanCell(userId ?? "", "name");
   const displayName = name || auth?.session?.user.email || "Unknown";
   const [imgError, setImgError] = useState(false);
 
diff --git a/apps/desktop/src/search/components/sidebar/item.tsx b/apps/desktop/src/search/components/sidebar/item.tsx
index b8d3c7a2ec..8fc473c3dc 100644
--- a/apps/desktop/src/search/components/sidebar/item.tsx
+++ b/apps/desktop/src/search/components/sidebar/item.tsx
@@ -4,8 +4,8 @@ import { useCallback, useMemo } from "react";
 
 import { cn } from "@hypr/utils";
 
+import { useHumansByOrg } from "~/contacts/hooks";
 import { type SearchResult } from "~/search/contexts/ui";
-import * as main from "~/store/tinybase/store/main";
 import { type TabInput, useTabs } from "~/store/zustand/tabs";
 
 export function SearchResultItem({
@@ -117,11 +117,7 @@ function OrganizationSearchResultItem({
   onClick: () => void;
   isSelected: boolean;
 }) {
-  const humanIds = main.UI.useSliceRowIds(
-    main.INDEXES.humansByOrg,
-    result.id,
-    main.STORE_ID,
-  );
+  const humanIds = useHumansByOrg(result.id);
 
   const sanitizedTitle = useMemo(
     () =>
diff --git a/apps/desktop/src/search/contexts/engine/listeners.ts b/apps/desktop/src/search/contexts/engine/listeners.ts
index 3d7d73ed49..a63c4a7a79 100644
--- a/apps/desktop/src/search/contexts/engine/listeners.ts
+++ b/apps/desktop/src/search/contexts/engine/listeners.ts
@@ -1,4 +1,4 @@
-import { RowListener } from "tinybase/with-schemas";
+import type { RowListener } from "tinybase/with-schemas";
 
 import { commands as tantivy } from "@hypr/plugin-tantivy";
 
@@ -14,8 +14,7 @@ import {
   toTrimmedString,
 } from "./utils";
 
-import { Schemas } from "~/store/tinybase/store/main";
-import { type Store as MainStore } from "~/store/tinybase/store/main";
+import type { Schemas, Store as MainStore } from "~/store/tinybase/store/main";
 
 export function createSessionListener(): RowListener<
   Schemas,
diff --git a/apps/desktop/src/search/contexts/engine/utils.ts b/apps/desktop/src/search/contexts/engine/utils.ts
index c5f1281457..137bd545a7 100644
--- a/apps/desktop/src/search/contexts/engine/utils.ts
+++ b/apps/desktop/src/search/contexts/engine/utils.ts
@@ -1,3 +1,5 @@
+import { getSessionSearchTimestamp as getSharedSessionSearchTimestamp } from "~/session/utils";
+
 const SPACE_REGEX = /\s+/g;
 
 interface TiptapNode {
@@ -113,16 +115,7 @@ export function toEpochMs(value: unknown): number {
 export function getSessionSearchTimestamp(
   row: Record<string, unknown>,
 ): number {
-  const event = safeParseJSON(row.event_json);
-
-  if (event && typeof event === "object") {
-    const startedAt = toEpochMs((event as { started_at?: unknown }).started_at);
-    if (startedAt > 0) {
-      return startedAt;
-    }
-  }
-
-  return toEpochMs(row.created_at);
+  return getSharedSessionSearchTimestamp(row) ?? 0;
 }
 
 export function toString(value: unknown): string {
diff --git a/apps/desktop/src/services/calendar/ctx.ts b/apps/desktop/src/services/calendar/ctx.ts
index 1421b035ea..55c72d0d16 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,
@@ -11,7 +9,7 @@ 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,19 +26,21 @@ export interface Ctx {
 
 // ---
 
+export interface CreateCtxInput {
+  store: Store;
+  enabledCalendarIds: Iterable<string>;
+}
+
 export function createCtx(
-  store: Store,
-  queries: Queries<Schemas>,
+  input: CreateCtxInput,
   provider: CalendarProviderType,
   connectionId: string,
 ): Ctx | null {
-  const resultTable = queries.getResultTable(QUERIES.enabledCalendars);
-
   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 calendarId of input.enabledCalendarIds) {
+    const calendar = input.store.getRow("calendars", calendarId);
     if (
       calendar?.provider !== provider ||
       calendar?.connection_id !== connectionId
@@ -62,7 +62,7 @@ export function createCtx(
   //   return null;
   // }
 
-  const userId = store.getValue("user_id");
+  const userId = input.store.getValue("user_id");
   if (!userId) {
     return null;
   }
@@ -70,7 +70,7 @@ export function createCtx(
   const { from, to } = getRange();
 
   return {
-    store,
+    store: input.store,
     provider,
     connectionId,
     userId: String(userId),
diff --git a/apps/desktop/src/services/calendar/index.ts b/apps/desktop/src/services/calendar/index.ts
index b9df71f8aa..1fcef0ce99 100644
--- a/apps/desktop/src/services/calendar/index.ts
+++ b/apps/desktop/src/services/calendar/index.ts
@@ -1,8 +1,10 @@
-import type { Queries } from "tinybase/with-schemas";
+import type {
+  CalendarProviderType,
+  ProviderConnectionIds,
+} from "@hypr/plugin-calendar";
 
-import type { CalendarProviderType } from "@hypr/plugin-calendar";
-
-import { createCtx, getProviderConnections, syncCalendars } from "./ctx";
+import type { Ctx } from "./ctx";
+import { getProviderConnections } from "./ctx";
 import {
   CalendarFetchError,
   fetchExistingEvents,
@@ -16,27 +18,34 @@ import {
   syncSessionParticipants,
 } from "./process";
 
-import type { Schemas, Store } from "~/store/tinybase/store/main";
-
 export const CALENDAR_SYNC_TASK_ID = "calendarSync";
 
+export interface CalendarSyncDependencies {
+  createCtx: (
+    provider: CalendarProviderType,
+    connectionId: string,
+  ) => Ctx | null;
+  syncCalendars: (
+    providerConnections: ProviderConnectionIds[],
+  ) => Promise<void>;
+}
+
 export async function syncCalendarEvents(
-  store: Store,
-  queries: Queries<Schemas>,
+  deps: CalendarSyncDependencies,
 ): Promise<void> {
   await Promise.all([
     new Promise((resolve) => setTimeout(resolve, 250)),
-    run(store, queries),
+    run(deps),
   ]);
 }
 
-async function run(store: Store, queries: Queries<Schemas>) {
+async function run(deps: CalendarSyncDependencies) {
   const providerConnections = await getProviderConnections();
-  await syncCalendars(store, providerConnections);
+  await deps.syncCalendars(providerConnections);
   for (const { provider, connection_ids } of providerConnections) {
     for (const connectionId of connection_ids) {
       try {
-        await runForConnection(store, queries, provider, connectionId);
+        await runForConnection(deps, provider, connectionId);
       } catch (error) {
         console.error(
           `[calendar-sync] Error syncing ${provider} (${connectionId}): ${error}`,
@@ -47,12 +56,11 @@ async function run(store: Store, queries: Queries<Schemas>) {
 }
 
 async function runForConnection(
-  store: Store,
-  queries: Queries<Schemas>,
+  deps: CalendarSyncDependencies,
   provider: CalendarProviderType,
   connectionId: string,
 ) {
-  const ctx = createCtx(store, queries, provider, connectionId);
+  const ctx = deps.createCtx(provider, connectionId);
   if (!ctx) {
     return;
   }
diff --git a/apps/desktop/src/services/enhancer/index.ts b/apps/desktop/src/services/enhancer/index.ts
index 627884a72e..90886991c7 100644
--- a/apps/desktop/src/services/enhancer/index.ts
+++ b/apps/desktop/src/services/enhancer/index.ts
@@ -5,7 +5,6 @@ import { commands as analyticsCommands } from "@hypr/plugin-analytics";
 import { getEligibility } from "./eligibility";
 
 import type { Store as MainStore } from "~/store/tinybase/store/main";
-import { INDEXES } from "~/store/tinybase/store/main";
 import { createTaskId } from "~/store/zustand/ai-task/task-configs";
 import type { TasksActions } from "~/store/zustand/ai-task/tasks";
 import { listenerStore } from "~/store/zustand/listener/instance";
@@ -28,7 +27,13 @@ type EnhancerEvent =
 
 type EnhancerDeps = {
   mainStore: MainStore;
-  indexes: { getSliceRowIds: (indexId: string, sliceId: string) => string[] };
+  childIndex?: {
+    transcriptIdsBySession: (sessionId: string) => string[];
+    enhancedNoteIdsBySession: (sessionId: string) => string[];
+  };
+  indexes?: {
+    getSliceRowIds: (indexId: string, sliceId: string) => string[];
+  };
   aiTaskStore: {
     getState: () => Pick<TasksActions, "generate" | "getState" | "reset">;
   };
@@ -216,16 +221,21 @@ export class EnhancerService {
   }
 
   private getTranscriptIds(sessionId: string): string[] {
-    return this.deps.indexes.getSliceRowIds(
-      INDEXES.transcriptBySession,
-      sessionId,
+    if (this.deps.childIndex) {
+      return this.deps.childIndex.transcriptIdsBySession(sessionId);
+    }
+    return (
+      this.deps.indexes?.getSliceRowIds("transcriptBySession", sessionId) ?? []
     );
   }
 
   private getEnhancedNoteIds(sessionId: string): string[] {
-    return this.deps.indexes.getSliceRowIds(
-      INDEXES.enhancedNotesBySession,
-      sessionId,
+    if (this.deps.childIndex) {
+      return this.deps.childIndex.enhancedNoteIdsBySession(sessionId);
+    }
+    return (
+      this.deps.indexes?.getSliceRowIds("enhancedNotesBySession", sessionId) ??
+      []
     );
   }
 
diff --git a/apps/desktop/src/services/event-listeners.test.tsx b/apps/desktop/src/services/event-listeners.test.tsx
index 305de53a95..ffb96781db 100644
--- a/apps/desktop/src/services/event-listeners.test.tsx
+++ b/apps/desktop/src/services/event-listeners.test.tsx
@@ -128,4 +128,63 @@ describe("EventListeners notification events", () => {
     );
     expect(openNewMock).not.toHaveBeenCalled();
   });
+
+  test("uses refreshed session actions after the store hydrates", async () => {
+    const store = { id: "main-store" };
+    let currentStore: unknown = null;
+
+    useMainStoreMock.mockImplementation(() => currentStore as never);
+
+    const view = render(<EventListeners />);
+
+    await vi.waitFor(() =>
+      expect(notificationListenMock).toHaveBeenCalledTimes(1),
+    );
+
+    const handler = notificationListenMock.mock.calls[0]?.[0];
+    expect(handler).toBeTypeOf("function");
+
+    currentStore = store;
+    view.rerender(<EventListeners />);
+
+    handler({
+      payload: {
+        type: "notification_accept",
+        key: "calendar-1",
+        source: {
+          type: "calendar_event",
+          event_id: "event-1",
+        },
+      },
+    });
+
+    handler({
+      payload: {
+        type: "notification_option_selected",
+        key: "mic-1",
+        selected_index: 1,
+        source: {
+          type: "mic_detected",
+          event_ids: ["event-1"],
+        },
+      },
+    });
+
+    expect(getOrCreateSessionForEventIdMock).toHaveBeenCalledWith(
+      store,
+      "event-1",
+      undefined,
+    );
+    expect(createSessionMock).toHaveBeenCalledWith(store);
+    expect(openNewMock).toHaveBeenNthCalledWith(1, {
+      type: "sessions",
+      id: "session-event",
+      state: { view: null, autoStart: true },
+    });
+    expect(openNewMock).toHaveBeenNthCalledWith(2, {
+      type: "sessions",
+      id: "session-new",
+      state: { view: null, autoStart: true },
+    });
+  });
 });
diff --git a/apps/desktop/src/services/event-listeners.tsx b/apps/desktop/src/services/event-listeners.tsx
index c7fbab90c4..8733bd9182 100644
--- a/apps/desktop/src/services/event-listeners.tsx
+++ b/apps/desktop/src/services/event-listeners.tsx
@@ -8,11 +8,10 @@ import {
 } from "@hypr/plugin-updater2";
 import { getCurrentWebviewWindowLabel } from "@hypr/plugin-windows";
 
-import * as main from "~/store/tinybase/store/main";
 import {
-  createSession,
-  getOrCreateSessionForEventId,
-} from "~/store/tinybase/store/sessions";
+  useCreateSession,
+  useGetOrCreateSessionForEvent,
+} from "~/session/hooks/runtime";
 import * as settings from "~/store/tinybase/store/settings";
 import { useTabs } from "~/store/zustand/tabs";
 
@@ -62,34 +61,38 @@ function useUpdaterEvents() {
 }
 
 function useNotificationEvents() {
-  const store = main.UI.useStore(main.STORE_ID);
+  const createSession = useCreateSession();
+  const getOrCreateSessionForEvent = useGetOrCreateSessionForEvent();
   const settingsStore = settings.UI.useStore(settings.STORE_ID);
   const openNew = useTabs((state) => state.openNew);
   const pendingAutoStart = useRef<{ eventId: string | null } | null>(null);
-  const storeRef = useRef(store);
+  const createSessionRef = useRef(createSession);
+  const getOrCreateSessionForEventRef = useRef(getOrCreateSessionForEvent);
   const settingsStoreRef = useRef(settingsStore);
   const openNewRef = useRef(openNew);
 
-  useEffect(() => {
-    storeRef.current = store;
-    settingsStoreRef.current = settingsStore;
-    openNewRef.current = openNew;
-  }, [store, settingsStore, openNew]);
+  createSessionRef.current = createSession;
+  getOrCreateSessionForEventRef.current = getOrCreateSessionForEvent;
+  settingsStoreRef.current = settingsStore;
+  openNewRef.current = openNew;
 
   useEffect(() => {
-    if (pendingAutoStart.current && store) {
+    if (pendingAutoStart.current) {
       const { eventId } = pendingAutoStart.current;
       pendingAutoStart.current = null;
       const sessionId = eventId
-        ? getOrCreateSessionForEventId(store, eventId)
-        : createSession(store);
+        ? (getOrCreateSessionForEventRef.current(eventId) ?? null)
+        : createSessionRef.current();
+      if (!sessionId) {
+        return;
+      }
       openNew({
         type: "sessions",
         id: sessionId,
         state: { view: null, autoStart: true },
       });
     }
-  }, [store, openNew]);
+  }, [createSession, getOrCreateSessionForEvent, openNew]);
 
   useEffect(() => {
     if (getCurrentWebviewWindowLabel() !== "main") {
@@ -109,36 +112,35 @@ function useNotificationEvents() {
             payload.source?.type === "calendar_event"
               ? payload.source.event_id
               : null;
-          const currentStore = storeRef.current;
-          if (!currentStore) {
+          const sessionId = eventId
+            ? getOrCreateSessionForEventRef.current(eventId)
+            : createSessionRef.current();
+          if (!sessionId) {
             pendingAutoStart.current = { eventId };
             return;
           }
-          const sessionId = eventId
-            ? 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;
-
           const selectedIndex = payload.selected_index;
           const eventIds =
             payload.source?.type === "mic_detected"
               ? (payload.source.event_ids ?? [])
               : [];
+          const eventId =
+            selectedIndex < eventIds.length ? eventIds[selectedIndex] : null;
 
           const sessionId =
-            selectedIndex < eventIds.length
-              ? getOrCreateSessionForEventId(
-                  currentStore,
-                  eventIds[selectedIndex],
-                )
-              : createSession(currentStore);
+            eventId !== null
+              ? getOrCreateSessionForEventRef.current(eventId)
+              : createSessionRef.current();
+          if (!sessionId) {
+            pendingAutoStart.current = { eventId };
+            return;
+          }
 
           openNewRef.current({
             type: "sessions",
diff --git a/apps/desktop/src/services/task-manager.tsx b/apps/desktop/src/services/task-manager.tsx
index f983d00837..e2a7dec7db 100644
--- a/apps/desktop/src/services/task-manager.tsx
+++ b/apps/desktop/src/services/task-manager.tsx
@@ -1,5 +1,4 @@
 import { useEffect, useRef } from "react";
-import type { Queries } from "tinybase/with-schemas";
 import {
   useScheduleTaskRun,
   useScheduleTaskRunCallback,
@@ -8,7 +7,7 @@ import {
 
 import { events as appleCalendarEvents } from "@hypr/plugin-calendar";
 
-import { CALENDAR_SYNC_TASK_ID, syncCalendarEvents } from "./calendar";
+import { CALENDAR_SYNC_TASK_ID } from "./calendar";
 import {
   checkEventNotifications,
   EVENT_NOTIFICATION_INTERVAL,
@@ -16,24 +15,23 @@ import {
   type NotifiedEventsMap,
 } from "./event-notification";
 
-import * as main from "~/store/tinybase/store/main";
+import { useSyncCalendarEvents } from "~/calendar/hooks";
+import { useMainStoreInternal } from "~/session/hooks/internal";
+import type { Store } from "~/store/tinybase/store/main";
 import * as settings from "~/store/tinybase/store/settings";
 
 const CALENDAR_SYNC_INTERVAL = 60 * 1000; // 60 sec
 
 export function TaskManager() {
-  const store = main.UI.useStore(main.STORE_ID);
-  const queries = main.UI.useQueries(main.STORE_ID);
+  const store = useMainStoreInternal();
+  const syncCalendarEvents = useSyncCalendarEvents();
 
   const settingsStore = settings.UI.useStore(settings.STORE_ID);
   const notifiedEventsRef = useRef<NotifiedEventsMap>(new Map());
 
   useSetTask(CALENDAR_SYNC_TASK_ID, async () => {
-    await syncCalendarEvents(
-      store as main.Store,
-      queries as Queries<main.Schemas>,
-    );
-  }, [store, queries, settingsStore]);
+    await syncCalendarEvents();
+  }, [syncCalendarEvents]);
 
   useScheduleTaskRun(CALENDAR_SYNC_TASK_ID, undefined, 0, {
     repeatDelay: CALENDAR_SYNC_INTERVAL,
@@ -58,7 +56,7 @@ export function TaskManager() {
   useSetTask(EVENT_NOTIFICATION_TASK_ID, async () => {
     if (!store || !settingsStore) return;
     checkEventNotifications(
-      store as main.Store,
+      store as Store,
       settingsStore as settings.Store,
       notifiedEventsRef.current,
     );
diff --git a/apps/desktop/src/session/components/bottom-accessory/during-session.tsx b/apps/desktop/src/session/components/bottom-accessory/during-session.tsx
index 66ad6c7362..daf022c249 100644
--- a/apps/desktop/src/session/components/bottom-accessory/during-session.tsx
+++ b/apps/desktop/src/session/components/bottom-accessory/during-session.tsx
@@ -4,18 +4,17 @@ import { useMemo, useRef } from "react";
 import { cn } from "@hypr/utils";
 
 import { getSegmentColor } from "~/session/components/note-input/transcript/renderer/utils";
-import * as main from "~/store/tinybase/store/main";
+import {
+  useTranscriptLabelContext,
+  useTranscriptRenderRequest,
+  useTranscriptSpeakerLabelManager,
+  useTranscriptIdsForSession,
+} from "~/session/hooks/transcripts";
 import { getLiveCaptureUiMode } from "~/store/zustand/listener/general-shared";
 import { useListener } from "~/stt/contexts";
 import { SegmentKeyUtils, type Segment } from "~/stt/live-segment";
-import {
-  buildRenderTranscriptRequestFromStore,
-  renderTranscriptSegments,
-} from "~/stt/render-transcript";
-import {
-  SpeakerLabelManager,
-  defaultRenderLabelContext,
-} from "~/stt/segment/shared";
+import { renderTranscriptSegments } from "~/stt/render-transcript";
+import { SpeakerLabelManager } from "~/stt/segment/shared";
 
 export function DuringSessionAccessory({
   sessionId,
@@ -50,7 +49,6 @@ function LiveTranscriptFooter({
   sessionId: string;
   isExpanded?: boolean;
 }) {
-  const store = main.UI.useStore(main.STORE_ID);
   const segments = useLiveTranscriptSegments(sessionId);
   const requestedLiveTranscription = useListener(
     (state) => state.live.requestedLiveTranscription,
@@ -58,10 +56,7 @@ function LiveTranscriptFooter({
   const liveTranscriptionActive = useListener(
     (state) => state.live.liveTranscriptionActive,
   );
-  const labelContext = useMemo(
-    () => (store ? defaultRenderLabelContext(store) : undefined),
-    [store],
-  );
+  const labelContext = useTranscriptLabelContext();
   const captureMode = getLiveCaptureUiMode({
     requestedLiveTranscription,
     liveTranscriptionActive,
@@ -74,13 +69,7 @@ function LiveTranscriptFooter({
           isFallbackFromLive: captureMode === "fallback_record_only",
         };
 
-  const speakerLabelManager = useMemo(() => {
-    if (!store) {
-      return new SpeakerLabelManager();
-    }
-
-    return SpeakerLabelManager.fromSegments(segments, labelContext);
-  }, [labelContext, segments, store]);
+  const speakerLabelManager = useTranscriptSpeakerLabelManager(segments);
 
   const scrollRef = useRef<HTMLDivElement>(null);
   const previewText = useMemo(() => getTranscriptPreview(segments), [segments]);
@@ -133,7 +122,7 @@ function LiveTranscriptContent({
   previewText: string | null;
   scrollRef: React.RefObject<HTMLDivElement | null>;
   segments: Segment[];
-  labelContext: ReturnType<typeof defaultRenderLabelContext> | undefined;
+  labelContext: ReturnType<typeof useTranscriptLabelContext>;
   speakerLabelManager: SpeakerLabelManager;
 }) {
   if (!isExpanded) {
@@ -184,36 +173,9 @@ function CollapsedFooterMessage({ message }: { message: string }) {
 }
 
 function useLiveTranscriptSegments(sessionId: string): Segment[] {
-  const store = main.UI.useStore(main.STORE_ID);
-  const transcriptIds =
-    main.UI.useSliceRowIds(
-      main.INDEXES.transcriptBySession,
-      sessionId,
-      main.STORE_ID,
-    ) ?? [];
-  const transcriptsTable = main.UI.useTable("transcripts", main.STORE_ID);
-  const participantMappingsTable = main.UI.useTable(
-    "mapping_session_participant",
-    main.STORE_ID,
-  );
-  const humansTable = main.UI.useTable("humans", main.STORE_ID);
-  const selfHumanId = main.UI.useValue("user_id", main.STORE_ID);
+  const transcriptIds = useTranscriptIdsForSession(sessionId) ?? [];
   const liveSegments = useListener((state) => state.liveSegments);
-
-  const request = useMemo(() => {
-    if (!store || transcriptIds.length === 0) {
-      return null;
-    }
-
-    return buildRenderTranscriptRequestFromStore(store, transcriptIds);
-  }, [
-    store,
-    transcriptIds,
-    transcriptsTable,
-    participantMappingsTable,
-    humansTable,
-    selfHumanId,
-  ]);
+  const request = useTranscriptRenderRequest(transcriptIds);
 
   const { data: renderedSegments = [] } = useQuery({
     queryKey: ["live-transcript-footer-segments", sessionId, request],
diff --git a/apps/desktop/src/session/components/note-input/enhanced/editor.tsx b/apps/desktop/src/session/components/note-input/enhanced/editor.tsx
index 670d2d39a1..bdb702832e 100644
--- a/apps/desktop/src/session/components/note-input/enhanced/editor.tsx
+++ b/apps/desktop/src/session/components/note-input/enhanced/editor.tsx
@@ -1,14 +1,17 @@
 import { forwardRef, useMemo } from "react";
 
+import { useMentionConfig } from "~/chat/hooks/mention-config";
 import { parseJsonContent } from "~/editor/markdown";
 import {
   NoteEditor,
   type JSONContent,
   type NoteEditorRef,
 } from "~/editor/session";
-import { useSearchEngine } from "~/search/contexts/engine";
+import {
+  useEnhancedNoteCell,
+  useUpdateEnhancedNoteContent,
+} from "~/session/hooks/enhanced-notes";
 import { useFileUpload } from "~/shared/hooks/useFileUpload";
-import * as main from "~/store/tinybase/store/main";
 
 export const EnhancedEditor = forwardRef<
   NoteEditorRef,
@@ -19,77 +22,20 @@ export const EnhancedEditor = forwardRef<
   }
 >(({ sessionId, enhancedNoteId, onNavigateToTitle }, ref) => {
   const onFileUpload = useFileUpload(sessionId);
-  const content = main.UI.useCell(
-    "enhanced_notes",
-    enhancedNoteId,
-    "content",
-    main.STORE_ID,
-  );
+  const content = useEnhancedNoteCell(enhancedNoteId, "content");
 
   const initialContent = useMemo<JSONContent>(
-    () => parseJsonContent(content as string),
+    () => parseJsonContent(content),
     [content],
   );
 
-  const handleChange = main.UI.useSetPartialRowCallback(
-    "enhanced_notes",
-    enhancedNoteId,
-    (input: JSONContent) => ({ content: JSON.stringify(input) }),
-    [],
-    main.STORE_ID,
-  );
-
-  const { search } = useSearchEngine();
-  const sessions = main.UI.useResultTable(
-    main.QUERIES.timelineSessions,
-    main.STORE_ID,
-  );
-  const humans = main.UI.useResultTable(
-    main.QUERIES.visibleHumans,
-    main.STORE_ID,
-  );
-  const organizations = main.UI.useResultTable(
-    main.QUERIES.visibleOrganizations,
-    main.STORE_ID,
+  const persistContent = useUpdateEnhancedNoteContent(enhancedNoteId);
+  const handleChange = useMemo(
+    () => (input: JSONContent) => persistContent(JSON.stringify(input)),
+    [persistContent],
   );
 
-  const mentionConfig = useMemo(
-    () => ({
-      trigger: "@",
-      handleSearch: async (query: string) => {
-        if (query.trim()) {
-          const results = await search(query);
-          return results.slice(0, 5).map((hit) => ({
-            id: hit.document.id,
-            type: hit.document.type,
-            label: hit.document.title,
-          }));
-        }
-
-        const results: { id: string; type: string; label: string }[] = [];
-        Object.entries(sessions).forEach(([rowId, row]) => {
-          const title = row.title as string | undefined;
-          if (title) {
-            results.push({ id: rowId, type: "session", label: title });
-          }
-        });
-        Object.entries(humans).forEach(([rowId, row]) => {
-          const name = row.name as string | undefined;
-          if (name) {
-            results.push({ id: rowId, type: "human", label: name });
-          }
-        });
-        Object.entries(organizations).forEach(([rowId, row]) => {
-          const name = row.name as string | undefined;
-          if (name) {
-            results.push({ id: rowId, type: "organization", label: name });
-          }
-        });
-        return results.slice(0, 5);
-      },
-    }),
-    [search, sessions, humans, organizations],
-  );
+  const mentionConfig = useMentionConfig();
 
   const fileHandlerConfig = useMemo(() => ({ onFileUpload }), [onFileUpload]);
 
diff --git a/apps/desktop/src/session/components/note-input/enhanced/enhance-error.tsx b/apps/desktop/src/session/components/note-input/enhanced/enhance-error.tsx
index 663729d360..7330586e40 100644
--- a/apps/desktop/src/session/components/note-input/enhanced/enhance-error.tsx
+++ b/apps/desktop/src/session/components/note-input/enhanced/enhance-error.tsx
@@ -4,7 +4,7 @@ import { Button } from "@hypr/ui/components/ui/button";
 
 import { useAITask } from "~/ai/contexts";
 import { useLanguageModel } from "~/ai/hooks";
-import * as main from "~/store/tinybase/store/main";
+import { useEnhancedNoteCell } from "~/session/hooks/enhanced-notes";
 import { createTaskId } from "~/store/zustand/ai-task/task-configs";
 
 export function EnhanceError({
@@ -19,12 +19,7 @@ export function EnhanceError({
   const model = useLanguageModel("enhance");
   const generate = useAITask((state) => state.generate);
   const templateId =
-    (main.UI.useCell(
-      "enhanced_notes",
-      enhancedNoteId,
-      "template_id",
-      main.STORE_ID,
-    ) as string | undefined) || undefined;
+    useEnhancedNoteCell(enhancedNoteId, "template_id") || undefined;
 
   const handleRetry = () => {
     if (!model) return;
diff --git a/apps/desktop/src/session/components/note-input/enhanced/index.tsx b/apps/desktop/src/session/components/note-input/enhanced/index.tsx
index 68c9daaaf2..a6cc749102 100644
--- a/apps/desktop/src/session/components/note-input/enhanced/index.tsx
+++ b/apps/desktop/src/session/components/note-input/enhanced/index.tsx
@@ -8,7 +8,7 @@ import { StreamingView } from "./streaming";
 import { useAITaskTask } from "~/ai/hooks";
 import { useLLMConnectionStatus } from "~/ai/hooks";
 import type { NoteEditorRef } from "~/editor/session";
-import * as main from "~/store/tinybase/store/main";
+import { useEnhancedNoteCell } from "~/session/hooks/enhanced-notes";
 import { createTaskId } from "~/store/zustand/ai-task/task-configs";
 
 export const Enhanced = forwardRef<
@@ -22,14 +22,9 @@ export const Enhanced = forwardRef<
   const taskId = createTaskId(enhancedNoteId, "enhance");
   const llmStatus = useLLMConnectionStatus();
   const { status, error } = useAITaskTask(taskId, "enhance");
-  const content = main.UI.useCell(
-    "enhanced_notes",
-    enhancedNoteId,
-    "content",
-    main.STORE_ID,
-  );
+  const content = useEnhancedNoteCell(enhancedNoteId, "content");
 
-  const hasContent = typeof content === "string" && content.trim().length > 0;
+  const hasContent = content.trim().length > 0;
 
   const isConfigError =
     llmStatus.status === "pending" ||
diff --git a/apps/desktop/src/session/components/note-input/header.tsx b/apps/desktop/src/session/components/note-input/header.tsx
index 4a5a14d745..ab2f9d4f3f 100644
--- a/apps/desktop/src/session/components/note-input/header.tsx
+++ b/apps/desktop/src/session/components/note-input/header.tsx
@@ -38,13 +38,18 @@ import { json2md, parseJsonContent } from "~/editor/markdown";
 import { extractPlainText } from "~/search/contexts/engine/utils";
 import { getEnhancerService } from "~/services/enhancer";
 import { useHasTranscript } from "~/session/components/shared";
+import {
+  useDeleteEnhancedNote,
+  useEnhancedNoteCell,
+} from "~/session/hooks/enhanced-notes";
+import { useSessionCell } from "~/session/hooks/sessions";
+import { useEnhancedNotes } from "~/session/hooks/useEnhancedNotes";
 import { useEnsureDefaultSummary } from "~/session/hooks/useEnhancedNotes";
 import {
   type MenuItemDef,
   useNativeContextMenu,
 } from "~/shared/hooks/useNativeContextMenu";
 import { useWebResources } from "~/shared/ui/resource-list";
-import * as main from "~/store/tinybase/store/main";
 import { createTaskId } from "~/store/zustand/ai-task/task-configs";
 import { type TaskStepInfo } from "~/store/zustand/ai-task/tasks";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
@@ -156,12 +161,7 @@ function HeaderTabRaw({
   onClick?: () => void;
   sessionId: string;
 }) {
-  const rawMd = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "raw_md",
-    main.STORE_ID,
-  ) as string | undefined;
+  const rawMd = useSessionCell(sessionId, "raw_md");
   const memoMarkdown = useMemo(() => getStoredNoteMarkdown(rawMd), [rawMd]);
   const contextMenu = useMemo<MenuItemDef[]>(
     () => [
@@ -209,24 +209,9 @@ function HeaderTabEnhanced({
 }) {
   const { isGenerating, isError, onRegenerate, onCancel, currentStep } =
     useEnhanceLogic(sessionId, enhancedNoteId);
-  const content = main.UI.useCell(
-    "enhanced_notes",
-    enhancedNoteId,
-    "content",
-    main.STORE_ID,
-  ) as string | undefined;
-  const rawTitle = main.UI.useCell(
-    "enhanced_notes",
-    enhancedNoteId,
-    "title",
-    main.STORE_ID,
-  );
-  const templateId = main.UI.useCell(
-    "enhanced_notes",
-    enhancedNoteId,
-    "template_id",
-    main.STORE_ID,
-  ) as string | undefined;
+  const content = useEnhancedNoteCell(enhancedNoteId, "content");
+  const rawTitle = useEnhancedNoteCell(enhancedNoteId, "title");
+  const templateId = useEnhancedNoteCell(enhancedNoteId, "template_id");
   const { data: template } = useUserTemplate(templateId);
   const templateTitle = template?.title?.trim() || null;
   const openTemplatesTab = useOpenTemplatesTab();
@@ -494,18 +479,8 @@ function CreateOtherFormatButton({
   const [search, setSearch] = useState("");
   const searchInputRef = useRef<HTMLInputElement>(null);
   const resultRefs = useRef<Array<HTMLButtonElement | null>>([]);
-  const sessionTitle = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "title",
-    main.STORE_ID,
-  ) as string | undefined;
-  const rawMd = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "raw_md",
-    main.STORE_ID,
-  ) as string | undefined;
+  const sessionTitle = useSessionCell(sessionId, "title");
+  const rawMd = useSessionCell(sessionId, "raw_md");
   const { data: transcriptSegments } = useTranscriptExportSegments(sessionId);
   const userTemplates = useUserTemplates();
   const createTemplate = useCreateTemplate();
@@ -1018,7 +993,7 @@ export function Header({
 }) {
   const sessionMode = useListener((state) => state.getSessionMode(sessionId));
   const isLiveProcessing = sessionMode === "active";
-  const store = main.UI.useStore(main.STORE_ID);
+  const deleteEnhancedNote = useDeleteEnhancedNote();
   const primaryEnhancedTabId = editorTabs.find(
     (view): view is Extract<EditorView, { type: "enhanced" }> =>
       view.type === "enhanced",
@@ -1053,7 +1028,7 @@ export function Header({
                               handleTabChange(previousView);
                             }
 
-                            store?.delRow("enhanced_notes", view.id);
+                            deleteEnhancedNote(view.id);
                           }
                         : undefined
                     }
@@ -1101,11 +1076,7 @@ export function useEditorTabs({
 
   const sessionMode = useListener((state) => state.getSessionMode(sessionId));
   const hasTranscript = useHasTranscript(sessionId);
-  const enhancedNoteIds = main.UI.useSliceRowIds(
-    main.INDEXES.enhancedNotesBySession,
-    sessionId,
-    main.STORE_ID,
-  );
+  const enhancedNoteIds = useEnhancedNotes(sessionId);
 
   if (sessionMode === "active") {
     return [{ type: "raw" }];
@@ -1131,12 +1102,7 @@ function useEnhanceLogic(sessionId: string, enhancedNoteId: string) {
   );
 
   const noteTemplateId =
-    (main.UI.useCell(
-      "enhanced_notes",
-      enhancedNoteId,
-      "template_id",
-      main.STORE_ID,
-    ) as string | undefined) || undefined;
+    useEnhancedNoteCell(enhancedNoteId, "template_id") || undefined;
 
   const enhanceTask = useAITaskTask(taskId, "enhance");
 
diff --git a/apps/desktop/src/session/components/note-input/raw.tsx b/apps/desktop/src/session/components/note-input/raw.tsx
index da4191dc6d..a20bb041b9 100644
--- a/apps/desktop/src/session/components/note-input/raw.tsx
+++ b/apps/desktop/src/session/components/note-input/raw.tsx
@@ -2,6 +2,7 @@ import { forwardRef, useCallback, useEffect, useMemo, useRef } from "react";
 
 import { commands as analyticsCommands } from "@hypr/plugin-analytics";
 
+import { useMentionConfig } from "~/chat/hooks/mention-config";
 import { parseJsonContent } from "~/editor/markdown";
 import {
   NoteEditor,
@@ -9,9 +10,8 @@ import {
   type NoteEditorRef,
   type PlaceholderFunction,
 } from "~/editor/session";
-import { useSearchEngine } from "~/search/contexts/engine";
+import { useSessionCell, useUpdateSessionCell } from "~/session/hooks/sessions";
 import { useFileUpload } from "~/shared/hooks/useFileUpload";
-import * as main from "~/store/tinybase/store/main";
 
 export const RawEditor = forwardRef<
   NoteEditorRef,
@@ -20,20 +20,20 @@ export const RawEditor = forwardRef<
     onNavigateToTitle?: (pixelWidth?: number) => void;
   }
 >(({ sessionId, onNavigateToTitle }, ref) => {
-  const rawMd = main.UI.useCell("sessions", sessionId, "raw_md", main.STORE_ID);
+  const rawMd = useSessionCell(sessionId, "raw_md");
   const onFileUpload = useFileUpload(sessionId);
 
   const initialContent = useMemo<JSONContent>(
-    () => parseJsonContent(rawMd as string),
+    () => parseJsonContent(rawMd),
     [rawMd],
   );
 
-  const persistChange = main.UI.useSetPartialRowCallback(
-    "sessions",
-    sessionId,
-    (input: JSONContent) => ({ raw_md: JSON.stringify(input) }),
-    [],
-    main.STORE_ID,
+  const setRawMd = useUpdateSessionCell(sessionId, "raw_md");
+  const persistChange = useCallback(
+    (input: JSONContent) => {
+      setRawMd(JSON.stringify(input));
+    },
+    [setRawMd],
   );
 
   const hasTrackedWriteRef = useRef(false);
@@ -67,57 +67,7 @@ export const RawEditor = forwardRef<
     [persistChange, hasNonEmptyText],
   );
 
-  const { search } = useSearchEngine();
-  const sessions = main.UI.useResultTable(
-    main.QUERIES.timelineSessions,
-    main.STORE_ID,
-  );
-  const humans = main.UI.useResultTable(
-    main.QUERIES.visibleHumans,
-    main.STORE_ID,
-  );
-  const organizations = main.UI.useResultTable(
-    main.QUERIES.visibleOrganizations,
-    main.STORE_ID,
-  );
-
-  const mentionConfig = useMemo(
-    () => ({
-      trigger: "@",
-      handleSearch: async (query: string) => {
-        if (query.trim()) {
-          const results = await search(query);
-          return results.slice(0, 5).map((hit) => ({
-            id: hit.document.id,
-            type: hit.document.type,
-            label: hit.document.title,
-          }));
-        }
-
-        const results: { id: string; type: string; label: string }[] = [];
-        Object.entries(sessions).forEach(([rowId, row]) => {
-          const title = row.title as string | undefined;
-          if (title) {
-            results.push({ id: rowId, type: "session", label: title });
-          }
-        });
-        Object.entries(humans).forEach(([rowId, row]) => {
-          const name = row.name as string | undefined;
-          if (name) {
-            results.push({ id: rowId, type: "human", label: name });
-          }
-        });
-        Object.entries(organizations).forEach(([rowId, row]) => {
-          const name = row.name as string | undefined;
-          if (name) {
-            results.push({ id: rowId, type: "organization", label: name });
-          }
-        });
-        return results.slice(0, 5);
-      },
-    }),
-    [search, sessions, humans, organizations],
-  );
+  const mentionConfig = useMentionConfig();
 
   const fileHandlerConfig = useMemo(() => ({ onFileUpload }), [onFileUpload]);
 
diff --git a/apps/desktop/src/session/components/note-input/transcript/export-data.ts b/apps/desktop/src/session/components/note-input/transcript/export-data.ts
index 0e16beb128..c076fccd17 100644
--- a/apps/desktop/src/session/components/note-input/transcript/export-data.ts
+++ b/apps/desktop/src/session/components/note-input/transcript/export-data.ts
@@ -1,13 +1,13 @@
 import { useQuery } from "@tanstack/react-query";
-import { useMemo } from "react";
 
 import type { TranscriptItem } from "@hypr/plugin-export";
+import type { RenderTranscriptRequest } from "@hypr/plugin-transcription";
 
-import * as main from "~/store/tinybase/store/main";
 import {
-  buildRenderTranscriptRequestFromStore,
-  renderTranscriptSegments,
-} from "~/stt/render-transcript";
+  useTranscriptRenderRequest,
+  useTranscriptIdsForSession,
+} from "~/session/hooks/transcripts";
+import { renderTranscriptSegments } from "~/stt/render-transcript";
 
 export type TranscriptExportSegment = TranscriptItem & {
   start_ms: number;
@@ -15,9 +15,7 @@ export type TranscriptExportSegment = TranscriptItem & {
 };
 
 export async function buildTranscriptExportSegments(
-  request: NonNullable<
-    ReturnType<typeof buildRenderTranscriptRequestFromStore>
-  >,
+  request: RenderTranscriptRequest,
 ): Promise<TranscriptExportSegment[]> {
   const segments = await renderTranscriptSegments(request);
 
@@ -33,36 +31,8 @@ export function useTranscriptExportSegments(sessionId: string): {
   data: TranscriptExportSegment[];
   isLoading: boolean;
 } {
-  const store = main.UI.useStore(main.STORE_ID);
-  const transcriptsTable = main.UI.useTable("transcripts", main.STORE_ID);
-  const participantMappingsTable = main.UI.useTable(
-    "mapping_session_participant",
-    main.STORE_ID,
-  );
-  const humansTable = main.UI.useTable("humans", main.STORE_ID);
-  const selfHumanId = main.UI.useValue("user_id", main.STORE_ID);
-
-  const transcriptIds =
-    main.UI.useSliceRowIds(
-      main.INDEXES.transcriptBySession,
-      sessionId,
-      main.STORE_ID,
-    ) ?? [];
-
-  const request = useMemo(() => {
-    if (!store || transcriptIds.length === 0) {
-      return null;
-    }
-
-    return buildRenderTranscriptRequestFromStore(store, transcriptIds);
-  }, [
-    store,
-    transcriptIds,
-    transcriptsTable,
-    participantMappingsTable,
-    humansTable,
-    selfHumanId,
-  ]);
+  const transcriptIds = useTranscriptIdsForSession(sessionId) ?? [];
+  const request = useTranscriptRenderRequest(transcriptIds);
 
   const { data = [], isLoading } = useQuery({
     queryKey: ["transcript-export-segments", sessionId, request],
diff --git a/apps/desktop/src/session/components/note-input/transcript/renderer/data-hooks.ts b/apps/desktop/src/session/components/note-input/transcript/renderer/data-hooks.ts
index 8218839199..22af544c45 100644
--- a/apps/desktop/src/session/components/note-input/transcript/renderer/data-hooks.ts
+++ b/apps/desktop/src/session/components/note-input/transcript/renderer/data-hooks.ts
@@ -1,37 +1,14 @@
 import { useQuery } from "@tanstack/react-query";
-import { useMemo } from "react";
 
-import * as main from "~/store/tinybase/store/main";
-import type { Segment } from "~/stt/live-segment";
 import {
-  buildRenderTranscriptRequestFromStore,
-  renderTranscriptSegments,
-} from "~/stt/render-transcript";
+  useTranscriptOffsetMs,
+  useTranscriptRenderRequest,
+} from "~/session/hooks/transcripts";
+import type { Segment } from "~/stt/live-segment";
+import { renderTranscriptSegments } from "~/stt/render-transcript";
 
 export function useRenderedTranscriptSegments(transcriptId: string): Segment[] {
-  const store = main.UI.useStore(main.STORE_ID);
-  const transcriptsTable = main.UI.useTable("transcripts", main.STORE_ID);
-  const participantMappingsTable = main.UI.useTable(
-    "mapping_session_participant",
-    main.STORE_ID,
-  );
-  const humansTable = main.UI.useTable("humans", main.STORE_ID);
-  const selfHumanId = main.UI.useValue("user_id", main.STORE_ID);
-
-  const request = useMemo(() => {
-    if (!store) {
-      return null;
-    }
-
-    return buildRenderTranscriptRequestFromStore(store, [transcriptId]);
-  }, [
-    store,
-    transcriptId,
-    transcriptsTable,
-    participantMappingsTable,
-    humansTable,
-    selfHumanId,
-  ]);
+  const request = useTranscriptRenderRequest([transcriptId]);
 
   const { data = [] } = useQuery({
     queryKey: ["rendered-transcript-segments", transcriptId, request],
@@ -49,49 +26,5 @@ export function useRenderedTranscriptSegments(transcriptId: string): Segment[] {
 }
 
 export function useTranscriptOffset(transcriptId: string): number {
-  const store = main.UI.useStore(main.STORE_ID);
-  const transcriptsTable = main.UI.useTable("transcripts", main.STORE_ID);
-  const sessionId = main.UI.useCell(
-    "transcripts",
-    transcriptId,
-    "session_id",
-    main.STORE_ID,
-  );
-
-  const transcriptIds = main.UI.useSliceRowIds(
-    main.INDEXES.transcriptBySession,
-    sessionId ?? "",
-    main.STORE_ID,
-  );
-
-  return useMemo(() => {
-    if (!store) {
-      return 0;
-    }
-
-    const transcriptStartedAt = store.getCell(
-      "transcripts",
-      transcriptId,
-      "started_at",
-    );
-    if (typeof transcriptStartedAt !== "number") {
-      return 0;
-    }
-
-    let earliestStartedAt = Number.POSITIVE_INFINITY;
-    for (const currentTranscriptId of transcriptIds ?? []) {
-      const startedAt = store.getCell(
-        "transcripts",
-        currentTranscriptId,
-        "started_at",
-      );
-      if (typeof startedAt === "number" && startedAt < earliestStartedAt) {
-        earliestStartedAt = startedAt;
-      }
-    }
-
-    return Number.isFinite(earliestStartedAt)
-      ? transcriptStartedAt - earliestStartedAt
-      : 0;
-  }, [store, transcriptId, transcriptIds, transcriptsTable]);
+  return useTranscriptOffsetMs(transcriptId);
 }
diff --git a/apps/desktop/src/session/components/note-input/transcript/renderer/segment-header.tsx b/apps/desktop/src/session/components/note-input/transcript/renderer/segment-header.tsx
index 1de2f54d7c..f295df72c0 100644
--- a/apps/desktop/src/session/components/note-input/transcript/renderer/segment-header.tsx
+++ b/apps/desktop/src/session/components/note-input/transcript/renderer/segment-header.tsx
@@ -5,10 +5,9 @@ import { cn } from "@hypr/utils";
 import { SpeakerAssignPopover } from "./speaker-assign";
 import { getTimestampRange, useSegmentColor } from "./utils";
 
-import * as main from "~/store/tinybase/store/main";
+import { useTranscriptLabelContext } from "~/session/hooks/transcripts";
 import type { Segment } from "~/stt/live-segment";
 import { SegmentKeyUtils, SpeakerLabelManager } from "~/stt/live-segment";
-import { defaultRenderLabelContext } from "~/stt/segment/shared";
 
 export function SegmentHeader({
   segment,
@@ -43,13 +42,12 @@ export function SegmentHeader({
 }
 
 function useSpeakerLabel(key: Segment["key"], manager?: SpeakerLabelManager) {
-  const store = main.UI.useStore(main.STORE_ID);
+  const labelContext = useTranscriptLabelContext();
 
   return useMemo(() => {
-    if (!store) {
+    if (!labelContext) {
       return SegmentKeyUtils.renderLabel(key, undefined, manager);
     }
-    const ctx = defaultRenderLabelContext(store);
-    return SegmentKeyUtils.renderLabel(key, ctx, manager);
-  }, [key, manager, store]);
+    return SegmentKeyUtils.renderLabel(key, labelContext, manager);
+  }, [key, labelContext, manager]);
 }
diff --git a/apps/desktop/src/session/components/note-input/transcript/renderer/speaker-assign.tsx b/apps/desktop/src/session/components/note-input/transcript/renderer/speaker-assign.tsx
index 030f548c65..5228670685 100644
--- a/apps/desktop/src/session/components/note-input/transcript/renderer/speaker-assign.tsx
+++ b/apps/desktop/src/session/components/note-input/transcript/renderer/speaker-assign.tsx
@@ -8,9 +8,12 @@ import {
 } from "@hypr/ui/components/ui/popover";
 import { cn } from "@hypr/utils";
 
-import * as main from "~/store/tinybase/store/main";
+import { useSessionParticipantPeople } from "~/session/hooks/participants";
+import {
+  useAssignTranscriptSpeaker,
+  useTranscriptSessionId,
+} from "~/session/hooks/transcripts";
 import type { Segment } from "~/stt/live-segment";
-import { upsertSpeakerAssignment } from "~/stt/utils";
 
 export function SpeakerAssignPopover({
   segment,
@@ -24,31 +27,25 @@ export function SpeakerAssignPopover({
   label: string;
 }) {
   const [open, setOpen] = useState(false);
-  const store = main.UI.useStore(main.STORE_ID);
+  const assignSpeaker = useAssignTranscriptSpeaker();
   const isSelf = segment.key.channel === "DirectMic";
 
-  const sessionId = main.UI.useCell(
-    "transcripts",
-    transcriptId,
-    "session_id",
-    main.STORE_ID,
-  ) as string | undefined;
+  const sessionId = useTranscriptSessionId(transcriptId);
 
   const handleAssign = useCallback(
     (humanId: string) => {
-      if (!store || segment.words.length === 0) return;
+      if (segment.words.length === 0) return;
       const anchorWordId = segment.words[0].id;
       if (!anchorWordId) return;
-      upsertSpeakerAssignment(
-        store,
+      assignSpeaker({
         transcriptId,
-        segment.key,
+        segmentKey: segment.key,
         humanId,
         anchorWordId,
-      );
+      });
       setOpen(false);
     },
-    [store, transcriptId, segment.key, segment.words],
+    [assignSpeaker, transcriptId, segment.key, segment.words],
   );
 
   if (isSelf) {
@@ -88,28 +85,11 @@ function ParticipantList({
   sessionId: string | undefined;
   onSelect: (humanId: string) => void;
 }) {
-  const queries = main.UI.useQueries(main.STORE_ID);
-
-  const mappingIds = main.UI.useSliceRowIds(
-    main.INDEXES.sessionParticipantsBySession,
-    sessionId ?? "",
-    main.STORE_ID,
-  ) as string[];
+  const participantsBySession = useSessionParticipantPeople(sessionId ?? "");
 
   const participants = useMemo(() => {
-    if (!queries) return [];
-    return mappingIds
-      .map((mappingId) => {
-        const result = queries.getResultRow(
-          main.QUERIES.sessionParticipantsWithDetails,
-          mappingId,
-        );
-        if (!result?.human_id) return null;
-        const name = (result.human_name as string) || "";
-        return { id: result.human_id as string, name };
-      })
-      .filter((p): p is { id: string; name: string } => p !== null);
-  }, [mappingIds, queries]);
+    return participantsBySession;
+  }, [participantsBySession]);
 
   if (participants.length === 0) {
     return (
diff --git a/apps/desktop/src/session/components/note-input/transcript/renderer/transcript.tsx b/apps/desktop/src/session/components/note-input/transcript/renderer/transcript.tsx
index 38902b7eb9..b92c91dea2 100644
--- a/apps/desktop/src/session/components/note-input/transcript/renderer/transcript.tsx
+++ b/apps/desktop/src/session/components/note-input/transcript/renderer/transcript.tsx
@@ -1,4 +1,4 @@
-import { memo, useCallback, useEffect, useMemo } from "react";
+import { memo, useCallback, useEffect } from "react";
 
 import { cn } from "@hypr/utils";
 
@@ -13,12 +13,8 @@ import {
   useStableSegments,
 } from "./segment-hooks";
 
-import * as main from "~/store/tinybase/store/main";
+import { useTranscriptSpeakerLabelManager } from "~/session/hooks/transcripts";
 import type { Segment, SegmentWord } from "~/stt/live-segment";
-import {
-  defaultRenderLabelContext,
-  SpeakerLabelManager,
-} from "~/stt/segment/shared";
 
 export function RenderTranscript({
   scrollElement,
@@ -88,14 +84,7 @@ const SegmentsList = memo(
     startPlayback: () => void;
     audioExists: boolean;
   }) => {
-    const store = main.UI.useStore(main.STORE_ID);
-    const speakerLabelManager = useMemo(() => {
-      if (!store) {
-        return new SpeakerLabelManager();
-      }
-      const ctx = defaultRenderLabelContext(store);
-      return SpeakerLabelManager.fromSegments(segments, ctx);
-    }, [segments, store]);
+    const speakerLabelManager = useTranscriptSpeakerLabelManager(segments);
 
     const seekAndPlay = useCallback(
       (word: SegmentWord) => {
diff --git a/apps/desktop/src/session/components/note-input/transcript/state.ts b/apps/desktop/src/session/components/note-input/transcript/state.ts
index a9dc556f5e..8ac05d3621 100644
--- a/apps/desktop/src/session/components/note-input/transcript/state.ts
+++ b/apps/desktop/src/session/components/note-input/transcript/state.ts
@@ -1,13 +1,13 @@
-import { useMemo } from "react";
-
 import type { DegradedError } from "@hypr/plugin-transcription";
 
 import { useAudioPlayer } from "~/audio-player";
-import * as main from "~/store/tinybase/store/main";
+import {
+  useTranscriptHasWords,
+  useTranscriptIdsForSession,
+} from "~/session/hooks/transcripts";
 import { getLiveCaptureUiMode } from "~/store/zustand/listener/general-shared";
 import { useListener } from "~/stt/contexts";
 import type { Segment } from "~/stt/live-segment";
-import { parseTranscriptWords } from "~/stt/utils";
 
 type ListeningStatus = "listening" | "finalizing";
 type BatchPhase = "importing" | "transcribing";
@@ -103,25 +103,9 @@ export function useTranscriptScreen({
 }
 
 function useTranscriptContent(sessionId: string) {
-  const transcriptIds =
-    main.UI.useSliceRowIds(
-      main.INDEXES.transcriptBySession,
-      sessionId,
-      main.STORE_ID,
-    ) ?? [];
-  const transcriptsTable = main.UI.useTable("transcripts", main.STORE_ID);
+  const transcriptIds = useTranscriptIdsForSession(sessionId) ?? [];
   const liveSegments = useListener((state) => state.liveSegments);
-  const store = main.UI.useStore(main.STORE_ID);
-
-  const hasTranscriptWords = useMemo(() => {
-    if (!store) {
-      return false;
-    }
-
-    return transcriptIds.some(
-      (transcriptId) => parseTranscriptWords(store, transcriptId).length > 0,
-    );
-  }, [store, transcriptIds, transcriptsTable]);
+  const hasTranscriptWords = useTranscriptHasWords(sessionId);
 
   return {
     transcriptIds,
diff --git a/apps/desktop/src/session/components/outer-header/folder/index.tsx b/apps/desktop/src/session/components/outer-header/folder/index.tsx
index ff40f0638d..1e6bedb1aa 100644
--- a/apps/desktop/src/session/components/outer-header/folder/index.tsx
+++ b/apps/desktop/src/session/components/outer-header/folder/index.tsx
@@ -15,18 +15,13 @@ import {
 } from "@hypr/ui/components/ui/tooltip";
 
 import { useBillingAccess } from "~/auth/billing";
+import { useSessionCell } from "~/session/hooks/sessions";
 import { FolderBreadcrumb } from "~/shared/ui/folder-breadcrumb";
-import * as main from "~/store/tinybase/store/main";
 import { useTabs } from "~/store/zustand/tabs";
 
 export function FolderChain({ sessionId }: { sessionId: string }) {
   const { isPro } = useBillingAccess();
-  const folderId = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "folder_id",
-    main.STORE_ID,
-  );
+  const folderId = useSessionCell(sessionId, "folder_id");
 
   if (!folderId) {
     return <UnassignedFolderBreadcrumb />;
diff --git a/apps/desktop/src/session/components/outer-header/folder/searchable-dropdown.tsx b/apps/desktop/src/session/components/outer-header/folder/searchable-dropdown.tsx
index d70336dfaf..a90648de9e 100644
--- a/apps/desktop/src/session/components/outer-header/folder/searchable-dropdown.tsx
+++ b/apps/desktop/src/session/components/outer-header/folder/searchable-dropdown.tsx
@@ -18,27 +18,25 @@ import {
 } from "@hypr/ui/components/ui/dropdown-menu";
 
 import { useBillingAccess } from "~/auth/billing";
+import { useSessionCell, useSessionFolderTree } from "~/session/hooks/sessions";
 import { sessionOps } from "~/store/tinybase/persister/session/ops";
-import * as main from "~/store/tinybase/store/main";
 import { useListener } from "~/stt/contexts";
 
 function useFolders() {
-  const sessionIds = main.UI.useRowIds("sessions", main.STORE_ID);
-  const store = main.UI.useStore(main.STORE_ID);
+  const { topLevel, byParent } = useSessionFolderTree();
 
   return useMemo(() => {
-    if (!store || !sessionIds) return {};
-
     const folders: Record<string, { name: string }> = {};
-    for (const id of sessionIds) {
-      const folderId = store.getCell("sessions", id, "folder_id") as string;
-      if (folderId && !folders[folderId]) {
+    const allFolders = [...topLevel, ...Object.values(byParent).flat()];
+
+    for (const folderId of allFolders) {
+      if (!folders[folderId]) {
         const parts = folderId.split("/");
         folders[folderId] = { name: parts[parts.length - 1] };
       }
     }
     return folders;
-  }, [sessionIds, store]);
+  }, [byParent, topLevel]);
 }
 
 export function SearchableFolderDropdown({
@@ -194,11 +192,7 @@ function useMoveSessionToFolder(sessionId: string) {
 }
 
 function useSessionFolderId(sessionId: string) {
-  return (
-    (main.UI.useCell("sessions", sessionId, "folder_id", main.STORE_ID) as
-      | string
-      | undefined) ?? ""
-  );
+  return useSessionCell(sessionId, "folder_id");
 }
 
 function useMoveDisabledReason(sessionId: string) {
diff --git a/apps/desktop/src/session/components/outer-header/metadata/date.test.tsx b/apps/desktop/src/session/components/outer-header/metadata/date.test.tsx
new file mode 100644
index 0000000000..d0f9075ca3
--- /dev/null
+++ b/apps/desktop/src/session/components/outer-header/metadata/date.test.tsx
@@ -0,0 +1,51 @@
+import { render, screen } from "@testing-library/react";
+import type React from "react";
+import { describe, expect, it, vi } from "vitest";
+
+const { useSessionCellOptionalMock, safeFormatMock } = vi.hoisted(() => ({
+  useSessionCellOptionalMock: vi.fn(() => undefined),
+  safeFormatMock: vi.fn(() => "Rendered date"),
+}));
+
+vi.mock("@hypr/ui/components/ui/button", () => ({
+  Button: ({
+    children,
+    ...props
+  }: React.ButtonHTMLAttributes<HTMLButtonElement>) => (
+    <button type="button" {...props}>
+      {children}
+    </button>
+  ),
+}));
+
+vi.mock("@hypr/ui/components/ui/input", () => ({
+  Input: (props: React.InputHTMLAttributes<HTMLInputElement>) => (
+    <input {...props} />
+  ),
+}));
+
+vi.mock("@hypr/utils", () => ({
+  format: vi.fn(),
+  safeParseDate: vi.fn(() => null),
+  safeFormat: safeFormatMock,
+}));
+
+vi.mock("~/session/hooks/sessions", () => ({
+  useSessionCellOptional: useSessionCellOptionalMock,
+  useSetSessionCreatedAt: vi.fn(() => vi.fn()),
+}));
+
+import { DateEditor } from "./date";
+
+describe("DateEditor", () => {
+  it("uses Date fallback when created_at is missing", () => {
+    render(<DateEditor sessionId="session-1" />);
+
+    expect(safeFormatMock).toHaveBeenCalledWith(
+      expect.any(Date),
+      "MMM d, yyyy h:mm a",
+      "Unknown date",
+    );
+    expect(screen.getByText("Rendered date")).not.toBeNull();
+  });
+});
diff --git a/apps/desktop/src/session/components/outer-header/metadata/date.tsx b/apps/desktop/src/session/components/outer-header/metadata/date.tsx
index 3564ff2375..7a60d6e5cb 100644
--- a/apps/desktop/src/session/components/outer-header/metadata/date.tsx
+++ b/apps/desktop/src/session/components/outer-header/metadata/date.tsx
@@ -6,16 +6,14 @@ import { Button } from "@hypr/ui/components/ui/button";
 import { Input } from "@hypr/ui/components/ui/input";
 import { format, safeFormat, safeParseDate } from "@hypr/utils";
 
-import * as main from "~/store/tinybase/store/main";
+import {
+  useSessionCellOptional,
+  useSetSessionCreatedAt,
+} from "~/session/hooks/sessions";
 
 export function DateEditor({ sessionId }: { sessionId: string }) {
   const [isEditing, setIsEditing] = useState(false);
-  const createdAt = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "created_at",
-    main.STORE_ID,
-  );
+  const createdAt = useSessionCellOptional(sessionId, "created_at");
   const noteDate = safeFormat(
     createdAt ?? new Date(),
     "MMM d, yyyy h:mm a",
@@ -64,14 +62,7 @@ function EditableDateForm({
   onCancel?: () => void;
   onSaved?: () => void;
 }) {
-  const handleChangeCreatedAt = main.UI.useSetCellCallback(
-    "sessions",
-    sessionId,
-    "created_at",
-    (value: string) => value,
-    [],
-    main.STORE_ID,
-  );
+  const handleChangeCreatedAt = useSetSessionCreatedAt(sessionId);
 
   const form = useForm({
     defaultValues: {
diff --git a/apps/desktop/src/session/components/outer-header/metadata/index.tsx b/apps/desktop/src/session/components/outer-header/metadata/index.tsx
index 57f373c701..9f189ac55b 100644
--- a/apps/desktop/src/session/components/outer-header/metadata/index.tsx
+++ b/apps/desktop/src/session/components/outer-header/metadata/index.tsx
@@ -21,9 +21,8 @@ import {
 import { DateEditor } from "./date";
 import { ParticipantsDisplay } from "./participants";
 
+import { useSessionCell, useSessionEvent } from "~/session/hooks/sessions";
 import { useConfigValue } from "~/shared/config";
-import { useSessionEvent } from "~/store/tinybase/hooks";
-import * as main from "~/store/tinybase/store/main";
 
 export function MetadataButton({ sessionId }: { sessionId: string }) {
   const [open, setOpen] = useState(false);
@@ -50,12 +49,7 @@ const TriggerInner = forwardRef<
   HTMLButtonElement,
   { sessionId: string; open?: boolean }
 >(({ sessionId, open, ...props }, ref) => {
-  const createdAt = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "created_at",
-    main.STORE_ID,
-  );
+  const createdAt = useSessionCell(sessionId, "created_at");
   const sessionEvent = useSessionEvent(sessionId);
 
   const hasEvent = !!sessionEvent;
diff --git a/apps/desktop/src/session/components/outer-header/metadata/participants/chip.tsx b/apps/desktop/src/session/components/outer-header/metadata/participants/chip.tsx
index 7d14f56e4c..2654b85f61 100644
--- a/apps/desktop/src/session/components/outer-header/metadata/participants/chip.tsx
+++ b/apps/desktop/src/session/components/outer-header/metadata/participants/chip.tsx
@@ -4,9 +4,12 @@ import { useCallback } from "react";
 import { Badge } from "@hypr/ui/components/ui/badge";
 import { Button } from "@hypr/ui/components/ui/button";
 
-import * as main from "~/store/tinybase/store/main";
+import {
+  useParticipantSourceCell,
+  useRemoveSessionParticipant,
+  useSessionParticipantDetails,
+} from "~/session/hooks/participants";
 import { useTabs } from "~/store/zustand/tabs/index";
-import { parseTranscriptHints, updateTranscriptHints } from "~/stt/utils";
 
 export function ParticipantChip({ mappingId }: { mappingId: string }) {
   const details = useParticipantDetails(mappingId);
@@ -61,55 +64,27 @@ export function ParticipantChip({ mappingId }: { mappingId: string }) {
 }
 
 function useParticipantDetails(mappingId: string) {
-  const result = main.UI.useResultRow(
-    main.QUERIES.sessionParticipantsWithDetails,
-    mappingId,
-    main.STORE_ID,
-  );
-  const source = main.UI.useCell(
-    "mapping_session_participant",
-    mappingId,
-    "source",
-    main.STORE_ID,
-  );
+  const details = useSessionParticipantDetails(mappingId);
+  const source = useParticipantSourceCell(mappingId);
 
-  if (!result) {
+  if (!details) {
     return null;
   }
 
   return {
     mappingId,
-    humanId: result.human_id as string,
-    humanName: (result.human_name as string) || "",
-    humanEmail: (result.human_email as string | undefined) || undefined,
-    humanJobTitle: (result.human_job_title as string | undefined) || undefined,
-    humanLinkedinUsername:
-      (result.human_linkedin_username as string | undefined) || undefined,
-    orgId: (result.org_id as string | undefined) || undefined,
-    orgName: result.org_name as string | undefined,
-    sessionId: result.session_id as string,
-    source: source as string | undefined,
+    humanId: details.humanId,
+    humanName: details.humanName || "",
+    humanEmail: details.humanEmail,
+    humanJobTitle: details.humanJobTitle,
+    humanLinkedinUsername: details.humanLinkedinUsername,
+    orgId: details.orgId,
+    orgName: details.orgName,
+    sessionId: details.sessionId,
+    source: source || undefined,
   };
 }
 
-function parseHumanIdFromHintValue(value: unknown): string | undefined {
-  let data = value;
-  if (typeof value === "string") {
-    try {
-      data = JSON.parse(value);
-    } catch {
-      return undefined;
-    }
-  }
-
-  if (data && typeof data === "object" && "human_id" in data) {
-    const humanId = (data as Record<string, unknown>).human_id;
-    return typeof humanId === "string" ? humanId : undefined;
-  }
-
-  return undefined;
-}
-
 function useRemoveParticipant({
   mappingId,
   assignedHumanId,
@@ -121,44 +96,9 @@ function useRemoveParticipant({
   sessionId: string | undefined;
   source: string | undefined;
 }) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
+  const removeParticipant = useRemoveSessionParticipant();
 
   return useCallback(() => {
-    if (!store) {
-      return;
-    }
-
-    if (assignedHumanId && sessionId && indexes) {
-      const transcriptIds = indexes.getSliceRowIds(
-        main.INDEXES.transcriptBySession,
-        sessionId,
-      );
-
-      for (const transcriptId of transcriptIds) {
-        const hints = parseTranscriptHints(store, transcriptId);
-        if (hints.length === 0) continue;
-
-        const filteredHints = hints.filter((hint) => {
-          if (hint.type !== "user_speaker_assignment") {
-            return true;
-          }
-          const hintHumanId = parseHumanIdFromHintValue(hint.value);
-          return hintHumanId !== assignedHumanId;
-        });
-
-        if (filteredHints.length !== hints.length) {
-          updateTranscriptHints(store, transcriptId, filteredHints);
-        }
-      }
-    }
-
-    if (source === "auto") {
-      store.setPartialRow("mapping_session_participant", mappingId, {
-        source: "excluded",
-      });
-    } else {
-      store.delRow("mapping_session_participant", mappingId);
-    }
-  }, [store, indexes, mappingId, assignedHumanId, sessionId, source]);
+    removeParticipant({ mappingId, assignedHumanId, sessionId, source });
+  }, [removeParticipant, mappingId, assignedHumanId, sessionId, source]);
 }
diff --git a/apps/desktop/src/session/components/outer-header/metadata/participants/input.tsx b/apps/desktop/src/session/components/outer-header/metadata/participants/input.tsx
index 57657d5466..c7fa8faa02 100644
--- a/apps/desktop/src/session/components/outer-header/metadata/participants/input.tsx
+++ b/apps/desktop/src/session/components/outer-header/metadata/participants/input.tsx
@@ -3,8 +3,13 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { ParticipantChip } from "./chip";
 import { ParticipantDropdown } from "./dropdown";
 
+import {
+  useSearchableHumans,
+  useSessionParticipantHumanIds,
+  useSessionParticipantMappingIds,
+  useSessionParticipantMutations,
+} from "~/session/hooks/participants";
 import { useAutoCloser } from "~/shared/hooks/useAutoCloser";
-import * as main from "~/store/tinybase/store/main";
 
 export function ParticipantInput({ sessionId }: { sessionId: string }) {
   const {
@@ -102,31 +107,12 @@ type Candidate = {
 };
 
 function useSessionParticipants(sessionId: string) {
-  const queries = main.UI.useQueries(main.STORE_ID);
-
-  const mappingIds = main.UI.useSliceRowIds(
-    main.INDEXES.sessionParticipantsBySession,
-    sessionId,
-    main.STORE_ID,
-  ) as string[];
+  const mappingIds = useSessionParticipantMappingIds(sessionId);
+  const participantHumanIds = useSessionParticipantHumanIds(sessionId);
 
   const existingHumanIds = useMemo(() => {
-    if (!queries) {
-      return new Set<string>();
-    }
-
-    const ids = new Set<string>();
-    for (const mappingId of mappingIds) {
-      const result = queries.getResultRow(
-        main.QUERIES.sessionParticipantsWithDetails,
-        mappingId,
-      );
-      if (result?.human_id) {
-        ids.add(result.human_id as string);
-      }
-    }
-    return ids;
-  }, [mappingIds, queries]);
+    return new Set(participantHumanIds);
+  }, [participantHumanIds]);
 
   return { mappingIds, existingHumanIds };
 }
@@ -135,39 +121,18 @@ function useCandidateSearch(
   inputValue: string,
   existingHumanIds: Set<string>,
 ): Candidate[] {
-  const store = main.UI.useStore(main.STORE_ID);
-  const allHumanIds = main.UI.useRowIds("humans", main.STORE_ID) as string[];
+  const humans = useSearchableHumans(inputValue, existingHumanIds);
 
   return useMemo(() => {
-    const searchLower = inputValue.toLowerCase();
-    return allHumanIds
-      .filter((humanId: string) => !existingHumanIds.has(humanId))
-      .map((humanId: string) => {
-        const human = store?.getRow("humans", humanId);
-        if (!human) {
-          return null;
-        }
-
-        const name = (human.name || "") as string;
-        const email = (human.email || "") as string;
-        const nameMatch = name.toLowerCase().includes(searchLower);
-        const emailMatch = email.toLowerCase().includes(searchLower);
-
-        if (inputValue && !nameMatch && !emailMatch) {
-          return null;
-        }
-
-        return {
-          id: humanId,
-          name,
-          email,
-          orgId: human.org_id as string | undefined,
-          jobTitle: human.job_title as string | undefined,
-          isNew: false,
-        };
-      })
-      .filter((h): h is NonNullable<typeof h> => h !== null);
-  }, [inputValue, allHumanIds, existingHumanIds, store]);
+    return humans.map((human) => ({
+      id: human.id,
+      name: human.name,
+      email: human.email,
+      orgId: human.orgId,
+      jobTitle: human.jobTitle,
+      isNew: false,
+    }));
+  }, [humans]);
 }
 
 function useDropdownOptions(
@@ -200,34 +165,38 @@ function useDropdownOptions(
 }
 
 function useParticipantMutations(sessionId: string, mappingIds: string[]) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
-
-  const createHuman = useCreateHuman(userId || "");
-  const linkHumanToSession = useLinkHumanToSession(userId || "", sessionId);
+  const mutations = useSessionParticipantMutations();
 
   const addParticipant = useCallback(
     (option: Candidate) => {
-      if (!userId) {
-        return;
-      }
-
       if (option.isNew) {
-        const humanId = createHuman(option.name);
-        linkHumanToSession(humanId);
+        const humanId = crypto.randomUUID();
+        mutations.createHuman({
+          id: humanId,
+          name: option.name,
+          email: "",
+        });
+        mutations.addParticipant({
+          sessionId,
+          humanId,
+          source: "manual",
+        });
       } else {
-        linkHumanToSession(option.id);
+        mutations.addParticipant({
+          sessionId,
+          humanId: option.id,
+          source: "manual",
+        });
       }
     },
-    [userId, createHuman, linkHumanToSession],
+    [mutations, sessionId],
   );
 
   const deleteLastParticipant = useCallback(() => {
-    if (mappingIds.length > 0 && store) {
-      const lastMappingId = mappingIds[mappingIds.length - 1];
-      store.delRow("mapping_session_participant", lastMappingId);
+    if (mappingIds.length > 0) {
+      mutations.deleteMapping(mappingIds[mappingIds.length - 1]);
     }
-  }, [mappingIds, store]);
+  }, [mappingIds, mutations]);
 
   return { addParticipant, deleteLastParticipant };
 }
@@ -287,57 +256,3 @@ function useParticipantInput(sessionId: string) {
     resetInput,
   };
 }
-
-function useLinkHumanToSession(
-  userId: string,
-  sessionId: string,
-): (humanId: string) => void {
-  const linkMapping = main.UI.useSetRowCallback(
-    "mapping_session_participant",
-    () => crypto.randomUUID(),
-    (p: { humanId: string }) => ({
-      user_id: userId,
-      created_at: new Date().toISOString(),
-      session_id: sessionId,
-      human_id: p.humanId,
-      source: "manual",
-    }),
-    [userId, sessionId],
-    main.STORE_ID,
-  );
-
-  return useCallback(
-    (humanId: string) => {
-      linkMapping({ humanId });
-    },
-    [linkMapping],
-  );
-}
-
-function useCreateHuman(userId: string): (name: string) => string {
-  const createHuman = main.UI.useSetRowCallback(
-    "humans",
-    (p: { name: string; humanId: string }) => p.humanId,
-    (p: { name: string; humanId: string }) => ({
-      user_id: userId,
-      created_at: new Date().toISOString(),
-      name: p.name,
-      email: "",
-      org_id: "",
-      job_title: "",
-      linkedin_username: "",
-      memo: "",
-    }),
-    [userId],
-    main.STORE_ID,
-  );
-
-  return useCallback(
-    (name: string) => {
-      const humanId = crypto.randomUUID();
-      createHuman({ name, humanId });
-      return humanId;
-    },
-    [createHuman],
-  );
-}
diff --git a/apps/desktop/src/session/components/outer-header/metadata/tags/chip.tsx b/apps/desktop/src/session/components/outer-header/metadata/tags/chip.tsx
index 21870d96a3..22885b7085 100644
--- a/apps/desktop/src/session/components/outer-header/metadata/tags/chip.tsx
+++ b/apps/desktop/src/session/components/outer-header/metadata/tags/chip.tsx
@@ -3,22 +3,16 @@ import { X } from "lucide-react";
 import { Badge } from "@hypr/ui/components/ui/badge";
 import { Button } from "@hypr/ui/components/ui/button";
 
-import * as main from "~/store/tinybase/store/main";
+import {
+  useSessionTagMutations,
+  useTagMappingCell,
+  useTagName,
+} from "~/session/hooks/tags";
 
 export function TagChip({ mappingId }: { mappingId: string }) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const tagId = main.UI.useCell(
-    "mapping_tag_session",
-    mappingId,
-    "tag_id",
-    main.STORE_ID,
-  ) as string | undefined;
-  const tagName = main.UI.useCell(
-    "tags",
-    tagId ?? "",
-    "name",
-    main.STORE_ID,
-  ) as string | undefined;
+  const tagId = useTagMappingCell(mappingId, "tag_id");
+  const tagName = useTagName(tagId);
+  const { deleteTagMapping } = useSessionTagMutations();
 
   if (!tagId || !tagName) {
     return null;
@@ -35,9 +29,7 @@ export function TagChip({ mappingId }: { mappingId: string }) {
         variant="ghost"
         size="sm"
         className="ml-0.5 h-3 w-3 p-0 hover:bg-transparent"
-        onClick={() => {
-          store?.delRow("mapping_tag_session", mappingId);
-        }}
+        onClick={() => deleteTagMapping(mappingId)}
       >
         <X className="h-2.5 w-2.5" />
       </Button>
diff --git a/apps/desktop/src/session/components/outer-header/metadata/tags/input.tsx b/apps/desktop/src/session/components/outer-header/metadata/tags/input.tsx
index 62e5f5f1ef..38234b96b8 100644
--- a/apps/desktop/src/session/components/outer-header/metadata/tags/input.tsx
+++ b/apps/desktop/src/session/components/outer-header/metadata/tags/input.tsx
@@ -1,15 +1,20 @@
-import { useCallback, useMemo, useRef, useState } from "react";
+import { useCallback, useRef, useState } from "react";
 
 import { TagChip } from "./chip";
 
-import * as main from "~/store/tinybase/store/main";
+import {
+  useAddSessionTag,
+  useSessionTagNameMap,
+  useSessionTagMappingIds,
+  useSessionTagMutations,
+} from "~/session/hooks/tags";
 
 export function TagInput({ sessionId }: { sessionId: string }) {
   const [inputValue, setInputValue] = useState("");
   const inputRef = useRef<HTMLInputElement>(null);
   const { mappingIds, existingTagIdsByName } = useSessionTags(sessionId);
   const addTag = useAddTag(sessionId, existingTagIdsByName);
-  const store = main.UI.useStore(main.STORE_ID);
+  const { deleteTagMapping } = useSessionTagMutations();
 
   const placeholder =
     mappingIds.length > 0 ? "Add another tag" : "Add tags to this note";
@@ -55,7 +60,7 @@ export function TagInput({ sessionId }: { sessionId: string }) {
           if (e.key === "Backspace" && !inputValue && mappingIds.length > 0) {
             const lastMappingId = mappingIds[mappingIds.length - 1];
             if (lastMappingId) {
-              store?.delRow("mapping_tag_session", lastMappingId);
+              deleteTagMapping(lastMappingId);
             }
           }
         }}
@@ -65,108 +70,17 @@ export function TagInput({ sessionId }: { sessionId: string }) {
 }
 
 function useSessionTags(sessionId: string) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const mappingIds = main.UI.useSliceRowIds(
-    main.INDEXES.tagSessionsBySession,
-    sessionId,
-    main.STORE_ID,
-  ) as string[];
-
-  const existingTagIdsByName = useMemo(() => {
-    const byName = new Map<string, string>();
-    for (const mappingId of mappingIds) {
-      const tagId = store?.getCell("mapping_tag_session", mappingId, "tag_id");
-      if (typeof tagId !== "string" || !tagId) {
-        continue;
-      }
-
-      const tagName = store?.getCell("tags", tagId, "name");
-      if (typeof tagName !== "string") {
-        continue;
-      }
-
-      byName.set(tagName.toLowerCase(), tagId);
-    }
-    return byName;
-  }, [mappingIds, store]);
+  const mappingIds = useSessionTagMappingIds(sessionId);
+  const existingTagIdsByName = useSessionTagNameMap(sessionId);
 
   return { mappingIds, existingTagIdsByName };
 }
 
 function useAddTag(
   sessionId: string,
-  existingTagIdsByName: Map<string, string>,
+  _existingTagIdsByName: Map<string, string>,
 ) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
-
-  return useCallback(
-    (name: string) => {
-      if (!store || !userId) {
-        return;
-      }
-
-      const normalized = name.toLowerCase();
-      const existingTagId = existingTagIdsByName.get(normalized);
-
-      let tagId = existingTagId;
-      if (!tagId) {
-        let foundTagId: string | null = null;
-        store.forEachRow("tags", (rowId, _forEachCell) => {
-          if (foundTagId) {
-            return;
-          }
-
-          const tagName = store.getCell("tags", rowId, "name");
-          if (
-            typeof tagName === "string" &&
-            tagName.toLowerCase() === normalized
-          ) {
-            foundTagId = rowId;
-          }
-        });
-
-        tagId = foundTagId ?? crypto.randomUUID();
-        if (!foundTagId) {
-          store.setRow("tags", tagId, {
-            user_id: userId,
-            name,
-          });
-        }
-      }
-
-      let hasMapping = false;
-      store.forEachRow("mapping_tag_session", (_rowId, _forEachCell) => {
-        if (hasMapping) {
-          return;
-        }
-
-        const currentTagId = store.getCell(
-          "mapping_tag_session",
-          _rowId,
-          "tag_id",
-        );
-        const currentSessionId = store.getCell(
-          "mapping_tag_session",
-          _rowId,
-          "session_id",
-        );
-
-        if (currentSessionId === sessionId && currentTagId === tagId) {
-          hasMapping = true;
-        }
-      });
-
-      if (!hasMapping) {
-        store.setRow("mapping_tag_session", crypto.randomUUID(), {
-          user_id: userId,
-          session_id: sessionId,
-          tag_id: tagId,
-        });
-      }
-    },
-    [existingTagIdsByName, sessionId, store, userId],
-  );
+  return useAddSessionTag(sessionId);
 }
 
 function normalizeTag(value: string): string {
diff --git a/apps/desktop/src/session/components/outer-header/overflow/delete.tsx b/apps/desktop/src/session/components/outer-header/overflow/delete.tsx
index 698358a71d..23ce325deb 100644
--- a/apps/desktop/src/session/components/outer-header/overflow/delete.tsx
+++ b/apps/desktop/src/session/components/outer-header/overflow/delete.tsx
@@ -2,16 +2,11 @@ import { Loader2Icon, TrashIcon } from "lucide-react";
 import { useCallback } from "react";
 
 import { commands as analyticsCommands } from "@hypr/plugin-analytics";
-import { commands as fsSyncCommands } from "@hypr/plugin-fs-sync";
 import { DropdownMenuItem } from "@hypr/ui/components/ui/dropdown-menu";
 import { cn } from "@hypr/utils";
 
 import { useAudioPlayer } from "~/audio-player";
-import {
-  captureSessionData,
-  deleteSessionCascade,
-} from "~/store/tinybase/store/deleteSession";
-import * as main from "~/store/tinybase/store/main";
+import { useDeleteSessionsWithUndo } from "~/session/hooks/runtime";
 import { useTabs } from "~/store/zustand/tabs";
 import { useUndoDelete } from "~/store/zustand/undo-delete";
 import { useListener } from "~/stt/contexts";
@@ -49,34 +44,22 @@ export function DeleteRecording({ sessionId }: { sessionId: string }) {
 }
 
 export function DeleteNote({ sessionId }: { sessionId: string }) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
+  const deleteSessionsWithUndo = useDeleteSessionsWithUndo();
   const invalidateResource = useTabs((state) => state.invalidateResource);
   const addDeletion = useUndoDelete((state) => state.addDeletion);
 
   const handleDeleteNote = useCallback(() => {
-    if (!store) {
-      return;
-    }
-
-    const capturedData = captureSessionData(store, indexes, sessionId);
-
-    invalidateResource("sessions", sessionId);
-    void deleteSessionCascade(store, indexes, sessionId, {
-      skipAudio: true,
+    deleteSessionsWithUndo({
+      sessionIds: [sessionId],
+      invalidateSessionResource: (id) => invalidateResource("sessions", id),
+      addDeletion,
     });
 
-    if (capturedData) {
-      addDeletion(capturedData, () => {
-        void fsSyncCommands.audioDelete(sessionId);
-      });
-    }
-
     void analyticsCommands.event({
       event: "session_deleted",
       includes_recording: true,
     });
-  }, [store, indexes, sessionId, invalidateResource, addDeletion]);
+  }, [sessionId, deleteSessionsWithUndo, invalidateResource, addDeletion]);
 
   return (
     <DropdownMenuItem
diff --git a/apps/desktop/src/session/components/outer-header/overflow/export-modal.tsx b/apps/desktop/src/session/components/outer-header/overflow/export-modal.tsx
index 74fd5d5aec..9248b12299 100644
--- a/apps/desktop/src/session/components/outer-header/overflow/export-modal.tsx
+++ b/apps/desktop/src/session/components/outer-header/overflow/export-modal.tsx
@@ -17,8 +17,10 @@ import { formatDate, formatDuration } from "./export-utils";
 
 import { json2md } from "~/editor/markdown";
 import { useTranscriptExportSegments } from "~/session/components/note-input/transcript/export-data";
-import { useSessionEvent } from "~/store/tinybase/hooks";
-import * as main from "~/store/tinybase/store/main";
+import { useEnhancedNoteCell } from "~/session/hooks/enhanced-notes";
+import { useSessionParticipantNames } from "~/session/hooks/participants";
+import { useSessionCell, useSessionEvent } from "~/session/hooks/sessions";
+import { useTranscriptTimeRange } from "~/session/hooks/transcripts";
 import type { EditorView } from "~/store/zustand/tabs/schema";
 
 type FileFormat = "pdf" | "txt" | "md" | "org";
@@ -66,110 +68,34 @@ export function ExportModal({
   const [includeSummary, setIncludeSummary] = useState(true);
   const [includeTranscript, setIncludeTranscript] = useState(false);
 
-  const store = main.UI.useStore(main.STORE_ID);
-  const queries = main.UI.useQueries(main.STORE_ID);
-
-  const sessionTitle = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "title",
-    main.STORE_ID,
-  ) as string | undefined;
-
-  const sessionCreatedAt = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "created_at",
-    main.STORE_ID,
-  ) as string | undefined;
+  const sessionTitle = useSessionCell(sessionId, "title");
+  const sessionCreatedAt = useSessionCell(sessionId, "created_at");
 
   const event = useSessionEvent(sessionId);
   const eventTitle = event?.title;
 
-  const rawMd = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "raw_md",
-    main.STORE_ID,
-  ) as string | undefined;
+  const rawMd = useSessionCell(sessionId, "raw_md");
 
   const enhancedNoteId = currentView.type === "enhanced" ? currentView.id : "";
-  const enhancedNoteContent = main.UI.useCell(
-    "enhanced_notes",
-    enhancedNoteId,
-    "content",
-    main.STORE_ID,
-  ) as string | undefined;
-
-  const participantNames = useMemo((): string[] => {
-    if (!queries) return [];
-
-    const names: string[] = [];
-    queries.forEachResultRow(
-      main.QUERIES.sessionParticipantsWithDetails,
-      (rowId) => {
-        const participantSessionId = queries.getResultCell(
-          main.QUERIES.sessionParticipantsWithDetails,
-          rowId,
-          "session_id",
-        );
-        if (participantSessionId === sessionId) {
-          const name = queries.getResultCell(
-            main.QUERIES.sessionParticipantsWithDetails,
-            rowId,
-            "human_name",
-          );
-          if (name && typeof name === "string") {
-            names.push(name);
-          }
-        }
-      },
-    );
-    return names;
-  }, [queries, sessionId]);
+  const enhancedNoteContent = useEnhancedNoteCell(enhancedNoteId, "content");
+
+  const participantNames = useSessionParticipantNames(sessionId);
 
   const { data: transcriptItems, isLoading: isTranscriptLoading } =
     useTranscriptExportSegments(sessionId);
 
-  const transcriptIds = main.UI.useSliceRowIds(
-    main.INDEXES.transcriptBySession,
-    sessionId,
-    main.STORE_ID,
-  );
+  const transcriptRange = useTranscriptTimeRange(sessionId);
 
   const transcriptDuration = useMemo((): string | null => {
-    if (!store || !transcriptIds || transcriptIds.length === 0) {
+    if (
+      transcriptRange.startedAt === null ||
+      transcriptRange.endedAt === null
+    ) {
       return null;
     }
 
-    let minStartedAt: number | null = null;
-    let maxEndedAt: number | null = null;
-
-    for (const transcriptId of transcriptIds) {
-      const startedAt = store.getCell(
-        "transcripts",
-        transcriptId,
-        "started_at",
-      );
-      const endedAt = store.getCell("transcripts", transcriptId, "ended_at");
-
-      if (typeof startedAt === "number") {
-        if (minStartedAt === null || startedAt < minStartedAt) {
-          minStartedAt = startedAt;
-        }
-      }
-      if (typeof endedAt === "number") {
-        if (maxEndedAt === null || endedAt > maxEndedAt) {
-          maxEndedAt = endedAt;
-        }
-      }
-    }
-
-    if (minStartedAt !== null && maxEndedAt !== null) {
-      return formatDuration(minStartedAt, maxEndedAt);
-    }
-    return null;
-  }, [store, transcriptIds]);
+    return formatDuration(transcriptRange.startedAt, transcriptRange.endedAt);
+  }, [transcriptRange.endedAt, transcriptRange.startedAt]);
 
   const getMemoMd = (): string => {
     if (!rawMd) return "";
diff --git a/apps/desktop/src/session/components/outer-header/overflow/export-pdf.test.tsx b/apps/desktop/src/session/components/outer-header/overflow/export-pdf.test.tsx
index 7e4aa0a08a..2608b3f44e 100644
--- a/apps/desktop/src/session/components/outer-header/overflow/export-pdf.test.tsx
+++ b/apps/desktop/src/session/components/outer-header/overflow/export-pdf.test.tsx
@@ -7,18 +7,16 @@ import { ExportPDF } from "./export-pdf";
 const {
   useMutationMock,
   useTranscriptExportSegmentsMock,
-  useStoreMock,
-  useQueriesMock,
   useCellMock,
-  useSliceRowIdsMock,
+  useSessionParticipantNamesMock,
+  useTranscriptTimeRangeMock,
   useSessionEventMock,
 } = vi.hoisted(() => ({
   useMutationMock: vi.fn(),
   useTranscriptExportSegmentsMock: vi.fn(),
-  useStoreMock: vi.fn(),
-  useQueriesMock: vi.fn(),
   useCellMock: vi.fn(),
-  useSliceRowIdsMock: vi.fn(),
+  useSessionParticipantNamesMock: vi.fn(),
+  useTranscriptTimeRangeMock: vi.fn(),
   useSessionEventMock: vi.fn(),
 }));
 
@@ -81,24 +79,21 @@ vi.mock("~/session/components/note-input/transcript/export-data", () => ({
   useTranscriptExportSegments: useTranscriptExportSegmentsMock,
 }));
 
-vi.mock("~/store/tinybase/hooks", () => ({
+vi.mock("~/session/hooks/enhanced-notes", () => ({
+  useEnhancedNoteCell: useCellMock,
+}));
+
+vi.mock("~/session/hooks/participants", () => ({
+  useSessionParticipantNames: useSessionParticipantNamesMock,
+}));
+
+vi.mock("~/session/hooks/sessions", () => ({
+  useSessionCell: useCellMock,
   useSessionEvent: useSessionEventMock,
 }));
 
-vi.mock("~/store/tinybase/store/main", () => ({
-  STORE_ID: "main",
-  INDEXES: {
-    transcriptBySession: "transcriptBySession",
-  },
-  QUERIES: {
-    sessionParticipantsWithDetails: "sessionParticipantsWithDetails",
-  },
-  UI: {
-    useStore: useStoreMock,
-    useQueries: useQueriesMock,
-    useCell: useCellMock,
-    useSliceRowIds: useSliceRowIdsMock,
-  },
+vi.mock("~/session/hooks/transcripts", () => ({
+  useTranscriptTimeRange: useTranscriptTimeRangeMock,
 }));
 
 describe("ExportPDF", () => {
@@ -115,10 +110,12 @@ describe("ExportPDF", () => {
       data: [],
       isLoading: true,
     });
-    useStoreMock.mockReturnValue(null);
-    useQueriesMock.mockReturnValue(null);
     useCellMock.mockReturnValue(undefined);
-    useSliceRowIdsMock.mockReturnValue([]);
+    useSessionParticipantNamesMock.mockReturnValue([]);
+    useTranscriptTimeRangeMock.mockReturnValue({
+      startedAt: null,
+      endedAt: null,
+    });
     useSessionEventMock.mockReturnValue(null);
   });
 
diff --git a/apps/desktop/src/session/components/outer-header/overflow/export-pdf.tsx b/apps/desktop/src/session/components/outer-header/overflow/export-pdf.tsx
index 75233ada86..e0dddc694a 100644
--- a/apps/desktop/src/session/components/outer-header/overflow/export-pdf.tsx
+++ b/apps/desktop/src/session/components/outer-header/overflow/export-pdf.tsx
@@ -15,8 +15,10 @@ import { DropdownMenuItem } from "@hypr/ui/components/ui/dropdown-menu";
 import { formatDate, formatDuration } from "./export-utils";
 
 import { json2md } from "~/editor/markdown";
-import { useSessionEvent } from "~/store/tinybase/hooks";
-import * as main from "~/store/tinybase/store/main";
+import { useEnhancedNoteCell } from "~/session/hooks/enhanced-notes";
+import { useSessionParticipantNames } from "~/session/hooks/participants";
+import { useSessionCell, useSessionEvent } from "~/session/hooks/sessions";
+import { useTranscriptTimeRange } from "~/session/hooks/transcripts";
 import type { EditorView } from "~/store/zustand/tabs/schema";
 
 export function ExportPDF({
@@ -26,107 +28,31 @@ export function ExportPDF({
   sessionId: string;
   currentView: EditorView;
 }) {
-  const store = main.UI.useStore(main.STORE_ID);
-  const queries = main.UI.useQueries(main.STORE_ID);
-
-  const sessionTitle = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "title",
-    main.STORE_ID,
-  ) as string | undefined;
-
-  const sessionCreatedAt = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "created_at",
-    main.STORE_ID,
-  ) as string | undefined;
+  const sessionTitle = useSessionCell(sessionId, "title");
+  const sessionCreatedAt = useSessionCell(sessionId, "created_at");
 
   const event = useSessionEvent(sessionId);
   const eventTitle = event?.title;
 
-  const rawMd = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "raw_md",
-    main.STORE_ID,
-  ) as string | undefined;
+  const rawMd = useSessionCell(sessionId, "raw_md");
 
   const enhancedNoteId = currentView.type === "enhanced" ? currentView.id : "";
-  const enhancedNoteContent = main.UI.useCell(
-    "enhanced_notes",
-    enhancedNoteId,
-    "content",
-    main.STORE_ID,
-  ) as string | undefined;
+  const enhancedNoteContent = useEnhancedNoteCell(enhancedNoteId, "content");
 
-  const participantNames = useMemo((): string[] => {
-    if (!queries) return [];
-
-    const names: string[] = [];
-    queries.forEachResultRow(
-      main.QUERIES.sessionParticipantsWithDetails,
-      (rowId) => {
-        const participantSessionId = queries.getResultCell(
-          main.QUERIES.sessionParticipantsWithDetails,
-          rowId,
-          "session_id",
-        );
-        if (participantSessionId === sessionId) {
-          const name = queries.getResultCell(
-            main.QUERIES.sessionParticipantsWithDetails,
-            rowId,
-            "human_name",
-          );
-          if (name && typeof name === "string") {
-            names.push(name);
-          }
-        }
-      },
-    );
-    return names;
-  }, [queries, sessionId]);
+  const participantNames = useSessionParticipantNames(sessionId);
 
-  const transcriptIds = main.UI.useSliceRowIds(
-    main.INDEXES.transcriptBySession,
-    sessionId,
-    main.STORE_ID,
-  );
+  const transcriptRange = useTranscriptTimeRange(sessionId);
 
   const transcriptDuration = useMemo((): string | null => {
-    if (!store || !transcriptIds || transcriptIds.length === 0) {
+    if (
+      transcriptRange.startedAt === null ||
+      transcriptRange.endedAt === null
+    ) {
       return null;
     }
 
-    let minStartedAt: number | null = null;
-    let maxEndedAt: number | null = null;
-
-    for (const transcriptId of transcriptIds) {
-      const startedAt = store.getCell(
-        "transcripts",
-        transcriptId,
-        "started_at",
-      );
-      const endedAt = store.getCell("transcripts", transcriptId, "ended_at");
-
-      if (typeof startedAt === "number") {
-        if (minStartedAt === null || startedAt < minStartedAt) {
-          minStartedAt = startedAt;
-        }
-      }
-      if (typeof endedAt === "number") {
-        if (maxEndedAt === null || endedAt > maxEndedAt) {
-          maxEndedAt = endedAt;
-        }
-      }
-    }
-
-    if (minStartedAt !== null && maxEndedAt !== null) {
-      return formatDuration(minStartedAt, maxEndedAt);
-    }
-    return null;
-  }, [store, transcriptIds]);
+    return formatDuration(transcriptRange.startedAt, transcriptRange.endedAt);
+  }, [transcriptRange.endedAt, transcriptRange.startedAt]);
 
   const getExportContent = useMemo(() => {
     return (): {
diff --git a/apps/desktop/src/session/components/session-preview-card.tsx b/apps/desktop/src/session/components/session-preview-card.tsx
index ac5ace6011..01fd2d3d4c 100644
--- a/apps/desktop/src/session/components/session-preview-card.tsx
+++ b/apps/desktop/src/session/components/session-preview-card.tsx
@@ -13,11 +13,12 @@ import { isValidContent, json2md } from "~/editor/markdown";
 import { parseImageMetadata } from "~/editor/node-views/image-view";
 import { extractPlainText } from "~/search/contexts/engine/utils";
 import { streamdownComponents } from "~/session/components/streamdown";
+import { useSessionParticipantNames } from "~/session/hooks/participants";
+import { useSessionCell } from "~/session/hooks/sessions";
 import {
   useEnhancedNote,
   useEnhancedNotes,
 } from "~/session/hooks/useEnhancedNotes";
-import * as main from "~/store/tinybase/store/main";
 
 const previewCardComponents: typeof streamdownComponents = {
   ...streamdownComponents,
@@ -116,34 +117,12 @@ function extractPreviewImage(markdown: string | null) {
 }
 
 function useSessionPreviewData(sessionId: string) {
-  const title =
-    (main.UI.useCell("sessions", sessionId, "title", main.STORE_ID) as
-      | string
-      | undefined) || "";
-  const rawMd = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "raw_md",
-    main.STORE_ID,
-  ) as string | undefined;
-  const createdAt = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "created_at",
-    main.STORE_ID,
-  ) as string | undefined;
-  const eventJson = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "event_json",
-    main.STORE_ID,
-  ) as string | undefined;
-
-  const participantMappingIds = main.UI.useSliceRowIds(
-    main.INDEXES.sessionParticipantsBySession,
-    sessionId,
-    main.STORE_ID,
-  );
+  const title = useSessionCell(sessionId, "title");
+  const rawMd = useSessionCell(sessionId, "raw_md");
+  const createdAt = useSessionCell(sessionId, "created_at");
+  const eventJson = useSessionCell(sessionId, "event_json");
+
+  const participantNames = useSessionParticipantNames(sessionId);
 
   const enhancedNoteIds = useEnhancedNotes(sessionId);
   const firstEnhancedNoteId = enhancedNoteIds?.[0];
@@ -210,7 +189,7 @@ function useSessionPreviewData(sessionId: string) {
     previewPlainText,
     previewLabel,
     dateDisplay,
-    participantMappingIds,
+    participantNames,
   };
 }
 
@@ -246,29 +225,9 @@ function useCursorFollow(axis: "x" | "y") {
   return { triggerRef, handleMouseMove, handleMouseLeave, style };
 }
 
-function useParticipantNames(mappingIds: string[]) {
-  const allResults = main.UI.useResultTable(
-    main.QUERIES.sessionParticipantsWithDetails,
-    main.STORE_ID,
-  );
-
-  return useMemo(() => {
-    const names: string[] = [];
-    for (const id of mappingIds) {
-      const row = allResults[id];
-      if (!row) continue;
-      const name = (row.human_name as string) || "Unknown";
-      names.push(name);
-    }
-    return names;
-  }, [mappingIds, allResults]);
-}
-
 const MAX_VISIBLE_PARTICIPANTS = 3;
 
-function ParticipantsList({ mappingIds }: { mappingIds: string[] }) {
-  const names = useParticipantNames(mappingIds);
-
+function ParticipantsList({ names }: { names: string[] }) {
   if (names.length === 0) return null;
 
   const visible = names.slice(0, MAX_VISIBLE_PARTICIPANTS);
@@ -300,7 +259,7 @@ export function SessionPreviewCard({
     previewMarkdown,
     previewPlainText,
     dateDisplay,
-    participantMappingIds,
+    participantNames,
   } = useSessionPreviewData(sessionId);
   const previewHasImage =
     !!previewMarkdown && MARKDOWN_IMAGE_REGEX.test(previewMarkdown);
@@ -363,7 +322,7 @@ export function SessionPreviewCard({
           )}
 
           <div className="text-sm font-medium">{title || "Untitled"}</div>
-          <ParticipantsList mappingIds={participantMappingIds} />
+          <ParticipantsList names={participantNames} />
 
           {previewMarkdown || previewPlainText ? (
             <div className="mt-1 flex max-h-32 flex-col overflow-hidden mask-[linear-gradient(to_bottom,black_60%,transparent)] text-neutral-600">
diff --git a/apps/desktop/src/session/components/shared.tsx b/apps/desktop/src/session/components/shared.tsx
index e01fd0ac05..8b00a12ef7 100644
--- a/apps/desktop/src/session/components/shared.tsx
+++ b/apps/desktop/src/session/components/shared.tsx
@@ -5,7 +5,8 @@ import { Button } from "@hypr/ui/components/ui/button";
 import { computeCurrentNoteTab } from "./compute-note-tab";
 
 import { useAITaskTask } from "~/ai/hooks";
-import * as main from "~/store/tinybase/store/main";
+import { useTranscriptIdsForSession } from "~/session/hooks/transcripts";
+import { useEnhancedNotes } from "~/session/hooks/useEnhancedNotes";
 import { createTaskId } from "~/store/zustand/ai-task/task-configs";
 import type { Tab } from "~/store/zustand/tabs/schema";
 import { type EditorView } from "~/store/zustand/tabs/schema";
@@ -14,12 +15,7 @@ import { useListener } from "~/stt/contexts";
 export { computeCurrentNoteTab } from "./compute-note-tab";
 
 export function useHasTranscript(sessionId: string): boolean {
-  const transcriptIds = main.UI.useSliceRowIds(
-    main.INDEXES.transcriptBySession,
-    sessionId,
-    main.STORE_ID,
-  );
-
+  const transcriptIds = useTranscriptIdsForSession(sessionId);
   return !!transcriptIds && transcriptIds.length > 0;
 }
 
@@ -29,11 +25,7 @@ export function useCurrentNoteTab(
   const sessionMode = useListener((state) => state.getSessionMode(tab.id));
   const isLiveSessionActive = sessionMode === "active";
 
-  const enhancedNoteIds = main.UI.useSliceRowIds(
-    main.INDEXES.enhancedNotesBySession,
-    tab.id,
-    main.STORE_ID,
-  );
+  const enhancedNoteIds = useEnhancedNotes(tab.id);
   const firstEnhancedNoteId = enhancedNoteIds?.[0];
 
   return useMemo(
diff --git a/apps/desktop/src/session/components/title-input.tsx b/apps/desktop/src/session/components/title-input.tsx
index f78a20420b..8bc04f491c 100644
--- a/apps/desktop/src/session/components/title-input.tsx
+++ b/apps/desktop/src/session/components/title-input.tsx
@@ -19,7 +19,7 @@ import {
 import { cn } from "@hypr/utils";
 
 import { useTitleGenerating } from "~/ai/hooks";
-import * as main from "~/store/tinybase/store/main";
+import { useSessionCell, useUpdateSessionCell } from "~/session/hooks/sessions";
 import { useLiveTitle } from "~/store/zustand/live-title";
 import { type Tab } from "~/store/zustand/tabs";
 
@@ -53,7 +53,7 @@ export const TitleInput = forwardRef<
       id: sessionId,
       state: { view },
     } = tab;
-    const store = main.UI.useStore(main.STORE_ID);
+    const storeTitle = useSessionCell(sessionId, "title");
     const isGenerating = useTitleGenerating(sessionId);
     const wasGenerating = usePrevious(isGenerating);
     const [showRevealAnimation, setShowRevealAnimation] = useState(false);
@@ -66,21 +66,18 @@ export const TitleInput = forwardRef<
 
     useEffect(() => {
       if (wasGenerating && !isGenerating) {
-        const title = store?.getCell("sessions", sessionId, "title") as
-          | string
-          | undefined;
-        setGeneratedTitle(title ?? null);
+        setGeneratedTitle(storeTitle || null);
         setShowRevealAnimation(true);
         const timer = setTimeout(() => {
           setShowRevealAnimation(false);
         }, 1000);
         return () => clearTimeout(timer);
       }
-    }, [wasGenerating, isGenerating, store, sessionId]);
+    }, [wasGenerating, isGenerating, storeTitle]);
 
     const getInitialTitle = useCallback(() => {
-      return (store?.getCell("sessions", sessionId, "title") as string) ?? "";
-    }, [store, sessionId]);
+      return storeTitle;
+    }, [storeTitle]);
 
     if (isGenerating) {
       return (
@@ -147,7 +144,7 @@ const TitleInputInner = memo(
       const [isTitleFocused, setIsTitleFocused] = useState(false);
       const isFocused = useRef(false);
       const internalRef = useRef<HTMLInputElement>(null);
-      const store = main.UI.useStore(main.STORE_ID);
+      const currentTitle = useSessionCell(sessionId, "title");
       const setLiveTitle = useLiveTitle((s) => s.setTitle);
       const clearLiveTitle = useLiveTitle((s) => s.clearTitle);
 
@@ -236,32 +233,13 @@ const TitleInputInner = memo(
       );
 
       useEffect(() => {
-        if (!store) return;
-
-        const listenerId = store.addCellListener(
-          "sessions",
-          sessionId,
-          "title",
-          (_store, _tableId, _rowId, _cellId, newValue) => {
-            if (!isFocused.current) {
-              setLocalTitle((newValue as string) ?? "");
-              requestAnimationFrame(() => updateOverflowState());
-            }
-          },
-        );
-
-        return () => {
-          store.delListener(listenerId);
-        };
-      }, [store, sessionId, updateOverflowState]);
+        if (!isFocused.current) {
+          setLocalTitle(currentTitle);
+          requestAnimationFrame(() => updateOverflowState());
+        }
+      }, [currentTitle, updateOverflowState]);
 
-      const setStoreTitle = main.UI.useSetPartialRowCallback(
-        "sessions",
-        sessionId,
-        (title: string) => ({ title }),
-        [],
-        main.STORE_ID,
-      );
+      const setStoreTitle = useUpdateSessionCell(sessionId, "title");
 
       const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
         if (e.key === "ArrowUp") {
diff --git a/apps/desktop/src/session/hooks/daily-notes.ts b/apps/desktop/src/session/hooks/daily-notes.ts
new file mode 100644
index 0000000000..07afbc505e
--- /dev/null
+++ b/apps/desktop/src/session/hooks/daily-notes.ts
@@ -0,0 +1,19 @@
+import { useCallback } from "react";
+
+import { useMainStoreInternal } from "~/session/hooks/internal";
+
+export function useUpdateDailyNoteContent(
+  date: string,
+): (contentJson: string) => void {
+  const store = useMainStoreInternal();
+  return useCallback(
+    (contentJson) => {
+      if (!store) return;
+      store.setPartialRow("daily_notes", date, {
+        content: contentJson,
+        date,
+      });
+    },
+    [store, date],
+  );
+}
diff --git a/apps/desktop/src/session/hooks/enhanced-notes.ts b/apps/desktop/src/session/hooks/enhanced-notes.ts
new file mode 100644
index 0000000000..a7d4988c8b
--- /dev/null
+++ b/apps/desktop/src/session/hooks/enhanced-notes.ts
@@ -0,0 +1,160 @@
+import { useCallback, useMemo } from "react";
+
+import { json2md, md2json, parseJsonContent } from "~/editor/markdown";
+import {
+  useMainIndexesInternal,
+  useMainStoreInternal,
+} from "~/session/hooks/internal";
+import * as main from "~/store/tinybase/store/main";
+
+export type SummaryEditCandidate = {
+  enhancedNoteId: string;
+  title: string;
+  templateId?: string;
+  position?: number;
+};
+
+export function useEnhancedNoteCell(
+  enhancedNoteId: string,
+  field: "title" | "content" | "template_id" | "position",
+): string {
+  const v = main.UI.useCell(
+    "enhanced_notes",
+    enhancedNoteId,
+    field,
+    main.STORE_ID,
+  );
+  return (v as string | undefined) ?? "";
+}
+
+// `error` is read off enhanced_notes in some paths but isn't in the
+// schema; treat it as an untyped escape hatch.
+export function useEnhancedNoteUntypedCell(
+  enhancedNoteId: string,
+  field: string,
+): string | undefined {
+  const v = main.UI.useCell(
+    "enhanced_notes",
+    enhancedNoteId,
+    field as "title",
+    main.STORE_ID,
+  );
+  return v as string | undefined;
+}
+
+export function useUpdateEnhancedNoteContent(
+  enhancedNoteId: string,
+): (content: string) => void {
+  return main.UI.useSetPartialRowCallback(
+    "enhanced_notes",
+    enhancedNoteId,
+    (content: string) => ({ content }),
+    [],
+    main.STORE_ID,
+  );
+}
+
+export function useDeleteEnhancedNote(): (enhancedNoteId: string) => void {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    (enhancedNoteId: string) => {
+      if (!store) return;
+      store.delRow("enhanced_notes", enhancedNoteId);
+    },
+    [store],
+  );
+}
+
+export function useEditTabTitles(
+  sessionId: string,
+  enhancedNoteId: string,
+): {
+  sessionTitle: string | null;
+  summaryTitle: string | null;
+} {
+  const sessionTitle = main.UI.useCell(
+    "sessions",
+    sessionId,
+    "title",
+    main.STORE_ID,
+  );
+  const summaryTitle = useEnhancedNoteCell(enhancedNoteId, "title");
+
+  return useMemo(
+    () => ({
+      sessionTitle:
+        typeof sessionTitle === "string" && sessionTitle.trim()
+          ? sessionTitle
+          : null,
+      summaryTitle:
+        typeof summaryTitle === "string" && summaryTitle.trim()
+          ? summaryTitle
+          : null,
+    }),
+    [sessionTitle, summaryTitle],
+  );
+}
+
+// Uses imperative store reads so that the returned callback identities stay
+// stable across enhanced_notes mutations. Chat tool registration depends on
+// this stability; subscribing to the whole table via useTable would churn
+// tool registration on every summary streaming tick.
+export function useSummaryEditRuntime(): {
+  getSummaryCandidates: (sessionId: string) => SummaryEditCandidate[];
+  getSummaryMarkdown: (enhancedNoteId: string) => string;
+  applySummaryMarkdown: (enhancedNoteId: string, markdown: string) => void;
+} {
+  const indexes = useMainIndexesInternal();
+  const store = useMainStoreInternal();
+
+  const getSummaryCandidates = useCallback(
+    (sessionId: string) => {
+      if (!indexes || !store) return [];
+      return indexes
+        .getSliceRowIds(main.INDEXES.enhancedNotesBySession, sessionId)
+        .map((enhancedNoteId) => {
+          const row = store.getRow("enhanced_notes", enhancedNoteId);
+          return {
+            enhancedNoteId,
+            title:
+              typeof row.title === "string" && row.title.trim()
+                ? row.title
+                : "Summary",
+            templateId:
+              typeof row.template_id === "string" && row.template_id
+                ? row.template_id
+                : undefined,
+            position:
+              typeof row.position === "number" ? row.position : undefined,
+          } satisfies SummaryEditCandidate;
+        });
+    },
+    [indexes, store],
+  );
+
+  const getSummaryMarkdown = useCallback(
+    (enhancedNoteId: string) => {
+      const raw = store?.getCell("enhanced_notes", enhancedNoteId, "content");
+      return json2md(
+        parseJsonContent(typeof raw === "string" ? raw : undefined),
+      );
+    },
+    [store],
+  );
+
+  const applySummaryMarkdown = useCallback(
+    (enhancedNoteId: string, markdown: string) => {
+      if (!store) {
+        throw new Error("Summary storage unavailable");
+      }
+      const json = md2json(markdown);
+      store.setPartialRow("enhanced_notes", enhancedNoteId, {
+        content: JSON.stringify(json),
+      });
+    },
+    [store],
+  );
+
+  return { getSummaryCandidates, getSummaryMarkdown, applySummaryMarkdown };
+}
diff --git a/apps/desktop/src/session/hooks/globals.ts b/apps/desktop/src/session/hooks/globals.ts
new file mode 100644
index 0000000000..9cbecf39a7
--- /dev/null
+++ b/apps/desktop/src/session/hooks/globals.ts
@@ -0,0 +1 @@
+export { useAiLanguage, useCurrentUserId } from "~/session/hooks/internal";
diff --git a/apps/desktop/src/session/hooks/internal.ts b/apps/desktop/src/session/hooks/internal.ts
new file mode 100644
index 0000000000..7b463240a8
--- /dev/null
+++ b/apps/desktop/src/session/hooks/internal.ts
@@ -0,0 +1,29 @@
+import * as main from "~/store/tinybase/store/main";
+
+export type MainStore = NonNullable<ReturnType<typeof main.UI.useStore>>;
+export type MainIndexes = NonNullable<ReturnType<typeof main.UI.useIndexes>>;
+export type MainQueries = ReturnType<typeof main.UI.useQueries>;
+export type SliceIndexReader = Pick<MainIndexes, "getSliceRowIds">;
+
+export function useMainStoreInternal(): MainStore | undefined {
+  return main.UI.useStore(main.STORE_ID);
+}
+
+export function useMainIndexesInternal(): MainIndexes | undefined {
+  return main.UI.useIndexes(main.STORE_ID);
+}
+
+export function useMainQueriesInternal(): MainQueries {
+  return main.UI.useQueries(main.STORE_ID);
+}
+
+export function useCurrentUserId(): string | undefined {
+  return main.UI.useValue("user_id", main.STORE_ID) as string | undefined;
+}
+
+export function useAiLanguage(): string {
+  return (
+    (main.UI.useValue("ai_language", main.STORE_ID) as string | undefined) ??
+    "en"
+  );
+}
diff --git a/apps/desktop/src/session/hooks/participants.ts b/apps/desktop/src/session/hooks/participants.ts
new file mode 100644
index 0000000000..051dd4bc8f
--- /dev/null
+++ b/apps/desktop/src/session/hooks/participants.ts
@@ -0,0 +1,355 @@
+import { useCallback, useMemo } from "react";
+
+import {
+  useMainIndexesInternal,
+  useMainStoreInternal,
+} from "~/session/hooks/internal";
+import * as main from "~/store/tinybase/store/main";
+import { updateTranscriptHints, parseTranscriptHints } from "~/stt/utils";
+
+export function useSessionParticipantMappingIds(sessionId: string): string[] {
+  return main.UI.useSliceRowIds(
+    main.INDEXES.sessionParticipantsBySession,
+    sessionId,
+    main.STORE_ID,
+  );
+}
+
+export type ParticipantDetails = {
+  mappingId: string;
+  sessionId: string;
+  humanId: string;
+  humanName?: string;
+  humanEmail?: string;
+  humanJobTitle?: string;
+  humanLinkedinUsername?: string;
+  orgId?: string;
+  orgName?: string;
+};
+
+export type SessionParticipantSummary = {
+  mappingId: string;
+  sessionId: string;
+  humanId: string;
+  source: string | undefined;
+  humanName: string | undefined;
+  humanEmail: string | undefined;
+  humanJobTitle: string | undefined;
+  humanLinkedinUsername: string | undefined;
+  orgId: string | undefined;
+  orgName: string | undefined;
+};
+
+type HumanSearchCandidate = {
+  id: string;
+  name: string;
+  email: string;
+  orgId: string | undefined;
+  jobTitle: string | undefined;
+};
+
+export function useSessionParticipantDetails(
+  mappingId: string,
+): ParticipantDetails | null {
+  const row = main.UI.useResultRow(
+    main.QUERIES.sessionParticipantsWithDetails,
+    mappingId,
+    main.STORE_ID,
+  );
+  return useMemo(() => {
+    if (!row || Object.keys(row).length === 0) return null;
+    return {
+      mappingId,
+      sessionId: (row.session_id as string) ?? "",
+      humanId: (row.human_id as string) ?? "",
+      humanName: row.human_name as string | undefined,
+      humanEmail: row.human_email as string | undefined,
+      humanJobTitle: row.human_job_title as string | undefined,
+      humanLinkedinUsername: row.human_linkedin_username as string | undefined,
+      orgId: row.org_id as string | undefined,
+      orgName: row.org_name as string | undefined,
+    };
+  }, [mappingId, row]);
+}
+
+export function useSessionParticipants(
+  sessionId: string,
+): SessionParticipantSummary[] {
+  const mappingIds = useSessionParticipantMappingIds(sessionId);
+  const mappingTable = main.UI.useTable(
+    "mapping_session_participant",
+    main.STORE_ID,
+  );
+  const participantRows = main.UI.useResultTable(
+    main.QUERIES.sessionParticipantsWithDetails,
+    main.STORE_ID,
+  );
+
+  return useMemo(() => {
+    return mappingIds
+      .map((mappingId) => {
+        const details = participantRows[mappingId];
+        if (!details) return null;
+
+        const humanId = details.human_id as string | undefined;
+        const mappedSessionId = details.session_id as string | undefined;
+        if (!humanId || mappedSessionId !== sessionId) return null;
+
+        const mappingRow = mappingTable[mappingId];
+        return {
+          mappingId,
+          sessionId: mappedSessionId,
+          humanId,
+          source: mappingRow?.source as string | undefined,
+          humanName: details.human_name as string | undefined,
+          humanEmail: details.human_email as string | undefined,
+          humanJobTitle: details.human_job_title as string | undefined,
+          humanLinkedinUsername: details.human_linkedin_username as
+            | string
+            | undefined,
+          orgId: details.org_id as string | undefined,
+          orgName: details.org_name as string | undefined,
+        } satisfies SessionParticipantSummary;
+      })
+      .filter((row): row is SessionParticipantSummary => row !== null);
+  }, [mappingIds, mappingTable, participantRows, sessionId]);
+}
+
+export function useSessionParticipantHumanIds(sessionId: string): string[] {
+  const participants = useSessionParticipants(sessionId);
+  return useMemo(
+    () =>
+      participants
+        .filter((participant) => participant.source !== "excluded")
+        .map((participant) => participant.humanId),
+    [participants],
+  );
+}
+
+export function useSessionParticipantNames(sessionId: string): string[] {
+  const participants = useSessionParticipants(sessionId);
+  return useMemo(
+    () =>
+      participants
+        .filter((participant) => participant.source !== "excluded")
+        .map((participant) => participant.humanName?.trim() ?? "")
+        .filter(Boolean),
+    [participants],
+  );
+}
+
+export function useSessionParticipantPeople(
+  sessionId: string,
+): { id: string; name: string }[] {
+  const participants = useSessionParticipants(sessionId);
+  return useMemo(() => {
+    return participants
+      .filter((participant) => participant.source !== "excluded")
+      .map((participant) => ({
+        id: participant.humanId,
+        name: participant.humanName?.trim() || "",
+      }))
+      .filter((participant) => participant.id.length > 0);
+  }, [participants]);
+}
+
+export function useSearchableHumans(
+  inputValue: string,
+  excludedHumanIds: Set<string>,
+): HumanSearchCandidate[] {
+  const humans = main.UI.useTable("humans", main.STORE_ID);
+
+  return useMemo(() => {
+    const searchLower = inputValue.trim().toLowerCase();
+
+    return Object.entries(humans)
+      .filter(([humanId]) => !excludedHumanIds.has(humanId))
+      .map(([humanId, row]) => {
+        const name = String(row.name ?? "");
+        const email = String(row.email ?? "");
+
+        if (
+          searchLower &&
+          !name.toLowerCase().includes(searchLower) &&
+          !email.toLowerCase().includes(searchLower)
+        ) {
+          return null;
+        }
+
+        return {
+          id: humanId,
+          name,
+          email,
+          orgId:
+            typeof row.org_id === "string" && row.org_id
+              ? row.org_id
+              : undefined,
+          jobTitle:
+            typeof row.job_title === "string" && row.job_title
+              ? row.job_title
+              : undefined,
+        } satisfies HumanSearchCandidate;
+      })
+      .filter((human): human is HumanSearchCandidate => human !== null);
+  }, [humans, inputValue, excludedHumanIds]);
+}
+
+export function useParticipantSourceCell(mappingId: string): string {
+  const v = main.UI.useCell(
+    "mapping_session_participant",
+    mappingId,
+    "source",
+    main.STORE_ID,
+  );
+  return (v as string | undefined) ?? "";
+}
+
+export function useAllHumanIds(): string[] {
+  return main.UI.useRowIds("humans", main.STORE_ID);
+}
+
+export function useSessionParticipantMutations(): {
+  addParticipant: (args: {
+    sessionId: string;
+    humanId: string;
+    source: string;
+  }) => string;
+  deleteMapping: (mappingId: string) => void;
+  updateMappingHumanId: (mappingId: string, humanId: string) => void;
+  createHuman: (args: { id: string; name: string; email: string }) => void;
+} {
+  const store = useMainStoreInternal();
+
+  const addParticipant = useCallback(
+    ({
+      sessionId,
+      humanId,
+      source,
+    }: {
+      sessionId: string;
+      humanId: string;
+      source: string;
+    }) => {
+      if (!store) return "";
+      const userId = (store.getValue("user_id") as string | undefined) ?? "";
+      if (!userId) return "";
+      const mappingId = crypto.randomUUID();
+      store.setRow("mapping_session_participant", mappingId, {
+        user_id: userId,
+        session_id: sessionId,
+        human_id: humanId,
+        source,
+      });
+      return mappingId;
+    },
+    [store],
+  );
+
+  const deleteMapping = useCallback(
+    (mappingId: string) => {
+      if (!store) return;
+      store.delRow("mapping_session_participant", mappingId);
+    },
+    [store],
+  );
+
+  const updateMappingHumanId = useCallback(
+    (mappingId: string, humanId: string) => {
+      if (!store) return;
+      store.setPartialRow("mapping_session_participant", mappingId, {
+        human_id: humanId,
+      });
+    },
+    [store],
+  );
+
+  const createHuman = useCallback(
+    ({ id, name, email }: { id: string; name: string; email: string }) => {
+      if (!store) return;
+      const userId = (store.getValue("user_id") as string | undefined) ?? "";
+      if (!userId) return;
+      store.setRow("humans", id, {
+        user_id: userId,
+        created_at: new Date().toISOString(),
+        name,
+        email,
+        org_id: "",
+        job_title: "",
+        linkedin_username: "",
+        memo: "",
+      });
+    },
+    [store],
+  );
+
+  return { addParticipant, deleteMapping, updateMappingHumanId, createHuman };
+}
+
+function parseHumanIdFromHintValue(value: unknown): string | undefined {
+  let data = value;
+  if (typeof value === "string") {
+    try {
+      data = JSON.parse(value);
+    } catch {
+      return undefined;
+    }
+  }
+
+  if (data && typeof data === "object" && "human_id" in data) {
+    const humanId = (data as Record<string, unknown>).human_id;
+    return typeof humanId === "string" ? humanId : undefined;
+  }
+
+  return undefined;
+}
+
+export function useRemoveSessionParticipant(): (args: {
+  mappingId: string;
+  assignedHumanId?: string;
+  sessionId?: string;
+  source?: string;
+}) => void {
+  const store = useMainStoreInternal();
+  const indexes = useMainIndexesInternal();
+
+  return useCallback(
+    ({ mappingId, assignedHumanId, sessionId, source }) => {
+      if (!store) {
+        return;
+      }
+
+      if (assignedHumanId && sessionId && indexes) {
+        const transcriptIds = indexes.getSliceRowIds(
+          main.INDEXES.transcriptBySession,
+          sessionId,
+        );
+
+        for (const transcriptId of transcriptIds) {
+          const hints = parseTranscriptHints(store, transcriptId);
+          if (hints.length === 0) continue;
+
+          const filteredHints = hints.filter((hint) => {
+            if (hint.type !== "user_speaker_assignment") {
+              return true;
+            }
+            const hintHumanId = parseHumanIdFromHintValue(hint.value);
+            return hintHumanId !== assignedHumanId;
+          });
+
+          if (filteredHints.length !== hints.length) {
+            updateTranscriptHints(store, transcriptId, filteredHints);
+          }
+        }
+      }
+
+      if (source === "auto") {
+        store.setPartialRow("mapping_session_participant", mappingId, {
+          source: "excluded",
+        });
+      } else {
+        store.delRow("mapping_session_participant", mappingId);
+      }
+    },
+    [indexes, store],
+  );
+}
diff --git a/apps/desktop/src/session/hooks/queries.ts b/apps/desktop/src/session/hooks/queries.ts
new file mode 100644
index 0000000000..54b6343c66
--- /dev/null
+++ b/apps/desktop/src/session/hooks/queries.ts
@@ -0,0 +1,132 @@
+import { useMemo } from "react";
+
+import type { SessionEvent } from "@hypr/store";
+
+import { getSessionEvent } from "~/session/utils";
+import * as main from "~/store/tinybase/store/main";
+
+export type MentionableEntity = {
+  id: string;
+  type: "session" | "human" | "organization";
+  label: string;
+};
+
+export type TimelineEventDto = {
+  id: string;
+  title: string;
+  startedAt: string;
+  endedAt: string;
+  calendarId: string;
+  trackingIdEvent: string;
+  hasRecurrenceRules: boolean;
+  recurrenceSeriesId: string;
+  isAllDay: boolean;
+};
+
+export type TimelineSessionDto = {
+  id: string;
+  title: string;
+  createdAt: string;
+  folderId: string;
+  event: SessionEvent | null;
+};
+
+export function useMentionableEntities(): MentionableEntity[] {
+  const sessionsTable = main.UI.useResultTable(
+    main.QUERIES.timelineSessions,
+    main.STORE_ID,
+  );
+  const humansTable = main.UI.useResultTable(
+    main.QUERIES.visibleHumans,
+    main.STORE_ID,
+  );
+  const organizationsTable = main.UI.useResultTable(
+    main.QUERIES.visibleOrganizations,
+    main.STORE_ID,
+  );
+
+  return useMemo(() => {
+    const results: MentionableEntity[] = [];
+
+    for (const [id, row] of Object.entries(sessionsTable)) {
+      const label =
+        typeof row.title === "string" && row.title.trim() ? row.title : "";
+      if (label) {
+        results.push({ id, type: "session", label });
+      }
+    }
+
+    for (const [id, row] of Object.entries(humansTable)) {
+      const label =
+        typeof row.name === "string" && row.name.trim() ? row.name : "";
+      if (label) {
+        results.push({ id, type: "human", label });
+      }
+    }
+
+    for (const [id, row] of Object.entries(organizationsTable)) {
+      const label =
+        typeof row.name === "string" && row.name.trim() ? row.name : "";
+      if (label) {
+        results.push({ id, type: "organization", label });
+      }
+    }
+
+    return results;
+  }, [humansTable, organizationsTable, sessionsTable]);
+}
+
+export function useTimelineEventMap(): Record<string, TimelineEventDto> {
+  const table = main.UI.useResultTable(
+    main.QUERIES.timelineEvents,
+    main.STORE_ID,
+  );
+
+  return useMemo(() => {
+    const out: Record<string, TimelineEventDto> = {};
+
+    for (const [id, row] of Object.entries(table)) {
+      out[id] = {
+        id,
+        title: (row.title as string) ?? "",
+        startedAt: (row.started_at as string) ?? "",
+        endedAt: (row.ended_at as string) ?? "",
+        calendarId: (row.calendar_id as string) ?? "",
+        trackingIdEvent: (row.tracking_id_event as string) ?? "",
+        hasRecurrenceRules: (row.has_recurrence_rules as boolean) ?? false,
+        recurrenceSeriesId: (row.recurrence_series_id as string) ?? "",
+        isAllDay: (row.is_all_day as boolean) ?? false,
+      };
+    }
+
+    return out;
+  }, [table]);
+}
+
+export function useTimelineSessionMap(): Record<string, TimelineSessionDto> {
+  const table = main.UI.useResultTable(
+    main.QUERIES.timelineSessions,
+    main.STORE_ID,
+  );
+
+  return useMemo(() => {
+    const out: Record<string, TimelineSessionDto> = {};
+
+    for (const [id, row] of Object.entries(table)) {
+      const event = getSessionEvent({
+        event_json:
+          typeof row.event_json === "string" ? row.event_json : undefined,
+      });
+
+      out[id] = {
+        id,
+        title: (row.title as string) ?? "",
+        createdAt: (row.created_at as string) ?? "",
+        folderId: (row.folder_id as string) ?? "",
+        event,
+      };
+    }
+
+    return out;
+  }, [table]);
+}
diff --git a/apps/desktop/src/session/hooks/runtime.ts b/apps/desktop/src/session/hooks/runtime.ts
new file mode 100644
index 0000000000..aa7076f2ea
--- /dev/null
+++ b/apps/desktop/src/session/hooks/runtime.ts
@@ -0,0 +1,431 @@
+import { useCallback, useMemo } from "react";
+
+import { commands as fsSyncCommands } from "@hypr/plugin-fs-sync";
+
+import type { ContextEntity, ContextRef } from "~/chat/context/entities";
+import { hydrateSessionContextFromFs } from "~/chat/context/session-context-hydrator";
+import type { ResolvedChatContext } from "~/chat/transport";
+import {
+  type SliceIndexReader,
+  useCurrentUserId,
+  useMainIndexesInternal,
+  useMainStoreInternal,
+} from "~/session/hooks/internal";
+import {
+  captureSessionData,
+  deleteSessionCascade,
+  restoreSessionData,
+} from "~/store/tinybase/store/deleteSession";
+import { importData } from "~/store/tinybase/store/importer";
+import * as main from "~/store/tinybase/store/main";
+import { save } from "~/store/tinybase/store/save";
+import {
+  createSession,
+  getOrCreateSessionForEventId,
+} from "~/store/tinybase/store/sessions";
+
+type CapturedSessionData = NonNullable<ReturnType<typeof captureSessionData>>;
+
+type AddDeletionFn = (
+  capturedData: CapturedSessionData,
+  onFinalize?: () => void,
+  batchId?: string,
+) => void;
+
+type PendingDeletionMap = Record<
+  string,
+  {
+    data: Parameters<typeof restoreSessionData>[1];
+  }
+>;
+
+export function useDisplayEntityRenderer(): (
+  ref: ContextRef,
+  removable: boolean,
+) => ContextEntity {
+  const sessionsTable = main.UI.useTable("sessions", main.STORE_ID);
+  const humansTable = main.UI.useTable("humans", main.STORE_ID);
+  const organizationsTable = main.UI.useTable("organizations", main.STORE_ID);
+
+  return useCallback(
+    (ref: ContextRef, removable: boolean): ContextEntity => {
+      if (ref.kind === "session") {
+        const row = sessionsTable[ref.sessionId];
+        return {
+          ...ref,
+          title:
+            typeof row?.title === "string" && row.title.trim()
+              ? row.title
+              : null,
+          date:
+            typeof row?.created_at === "string" && row.created_at.trim()
+              ? row.created_at
+              : null,
+          removable,
+        };
+      }
+
+      if (ref.kind === "human") {
+        const row = humansTable[ref.humanId];
+        const orgId = typeof row?.org_id === "string" ? row.org_id : null;
+        const organization =
+          orgId && organizationsTable[orgId] ? organizationsTable[orgId] : {};
+        return {
+          ...ref,
+          name:
+            typeof row?.name === "string" && row.name.trim() ? row.name : null,
+          email:
+            typeof row?.email === "string" && row.email.trim()
+              ? row.email
+              : null,
+          organizationName:
+            typeof organization.name === "string" && organization.name.trim()
+              ? organization.name
+              : null,
+          removable,
+        };
+      }
+
+      const row = organizationsTable[ref.organizationId];
+      return {
+        ...ref,
+        name:
+          typeof row?.name === "string" && row.name.trim() ? row.name : null,
+        removable,
+      };
+    },
+    [humansTable, organizationsTable, sessionsTable],
+  );
+}
+
+export function useResolveContextRef(): (
+  ref: ContextRef,
+) => Promise<ResolvedChatContext | null> {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    async (ref: ContextRef): Promise<ResolvedChatContext | null> => {
+      if (!store) return null;
+
+      if (ref.kind === "session") {
+        const context = await hydrateSessionContextFromFs(
+          store as Parameters<typeof hydrateSessionContextFromFs>[0],
+          ref.sessionId,
+        );
+        return context
+          ? ({ kind: "session", context } satisfies ResolvedChatContext)
+          : null;
+      }
+
+      if (ref.kind === "human") {
+        const human = store.getRow("humans", ref.humanId);
+        const orgId = typeof human.org_id === "string" ? human.org_id : "";
+        const organization =
+          orgId && store.hasRow("organizations", orgId)
+            ? store.getRow("organizations", orgId)
+            : {};
+
+        const name =
+          typeof human.name === "string" && human.name.trim()
+            ? human.name
+            : null;
+        const email =
+          typeof human.email === "string" && human.email.trim()
+            ? human.email
+            : null;
+        const jobTitle =
+          typeof human.job_title === "string" && human.job_title.trim()
+            ? human.job_title
+            : null;
+        const organizationName =
+          typeof organization.name === "string" && organization.name.trim()
+            ? organization.name
+            : null;
+        const memo =
+          typeof human.memo === "string" && human.memo.trim()
+            ? human.memo
+            : null;
+
+        if (!name && !email) return null;
+
+        const details = [
+          jobTitle,
+          organizationName ? `Organization: ${organizationName}` : null,
+          email ? `Email: ${email}` : null,
+          memo ? `Notes: ${memo}` : null,
+        ].filter(Boolean);
+
+        return {
+          kind: "text",
+          text: [`Referenced contact: ${name ?? email}`, ...details].join("\n"),
+        } satisfies ResolvedChatContext;
+      }
+
+      const organization = store.getRow("organizations", ref.organizationId);
+      const name =
+        typeof organization.name === "string" && organization.name.trim()
+          ? organization.name
+          : null;
+      return name
+        ? ({
+            kind: "text",
+            text: `Referenced organization: ${name}`,
+          } satisfies ResolvedChatContext)
+        : null;
+    },
+    [store],
+  );
+}
+
+export function useEnhancerSessionIndex():
+  | {
+      transcriptIdsBySession: (sessionId: string) => string[];
+      enhancedNoteIdsBySession: (sessionId: string) => string[];
+    }
+  | undefined {
+  const indexes = useMainIndexesInternal();
+
+  const transcriptIdsBySession = useCallback(
+    (sessionId: string) =>
+      indexes ? listTranscriptIdsBySession(indexes, sessionId) : [],
+    [indexes],
+  );
+
+  const enhancedNoteIdsBySession = useCallback(
+    (sessionId: string) =>
+      indexes ? listEnhancedNoteIdsBySession(indexes, sessionId) : [],
+    [indexes],
+  );
+
+  return useMemo(() => {
+    if (!indexes) return undefined;
+
+    return { transcriptIdsBySession, enhancedNoteIdsBySession };
+  }, [indexes, transcriptIdsBySession, enhancedNoteIdsBySession]);
+}
+
+export function listTranscriptIdsBySession(
+  indexes: SliceIndexReader,
+  sessionId: string,
+): string[] {
+  return indexes.getSliceRowIds(main.INDEXES.transcriptBySession, sessionId);
+}
+
+export function listEnhancedNoteIdsBySession(
+  indexes: SliceIndexReader,
+  sessionId: string,
+): string[] {
+  return indexes.getSliceRowIds(main.INDEXES.enhancedNotesBySession, sessionId);
+}
+
+export function useDeleteSessionsWithUndo(): (args: {
+  sessionIds: string[];
+  invalidateSessionResource: (sessionId: string) => void;
+  addDeletion: AddDeletionFn;
+  batchId?: string;
+}) => void {
+  const store = useMainStoreInternal();
+  const indexes = useMainIndexesInternal();
+
+  return useCallback(
+    ({ sessionIds, invalidateSessionResource, addDeletion, batchId }) => {
+      if (!store) return;
+
+      for (const sessionId of sessionIds) {
+        const capturedData = captureSessionData(store, indexes, sessionId);
+
+        invalidateSessionResource(sessionId);
+        void deleteSessionCascade(store, indexes, sessionId, {
+          skipAudio: true,
+        });
+
+        if (!capturedData) continue;
+
+        addDeletion(
+          capturedData,
+          () => {
+            void fsSyncCommands.audioDelete(sessionId);
+          },
+          batchId,
+        );
+      }
+    },
+    [store, indexes],
+  );
+}
+
+export function useRestoreDeletedSessions(): (args: {
+  sessionIds: string[];
+  pendingDeletions: PendingDeletionMap;
+  clearDeletion: (sessionId: string) => void;
+  clearBatch: (batchId: string) => void;
+  openSession: (sessionId: string) => void;
+  invalidateAudioQueries?: (sessionId: string) => void;
+  batchKey?: string;
+}) => void {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    ({
+      sessionIds,
+      pendingDeletions,
+      clearDeletion,
+      clearBatch,
+      openSession,
+      invalidateAudioQueries,
+      batchKey,
+    }) => {
+      if (!store) return;
+
+      for (const sessionId of sessionIds) {
+        const pending = pendingDeletions[sessionId];
+        if (!pending) continue;
+        restoreSessionData(
+          store as Parameters<typeof restoreSessionData>[0],
+          pending.data,
+        );
+        invalidateAudioQueries?.(sessionId);
+      }
+
+      if (sessionIds.length > 0) {
+        openSession(sessionIds[0]);
+      }
+
+      if (batchKey) {
+        clearBatch(batchKey);
+      } else if (sessionIds[0]) {
+        clearDeletion(sessionIds[0]);
+      }
+    },
+    [store],
+  );
+}
+
+export function useCreateSession(): () => string | null {
+  const store = useMainStoreInternal();
+
+  return useCallback(() => {
+    if (!store) return null;
+    return createSession(store);
+  }, [store]);
+}
+
+export function useGetOrCreateSessionForEvent(): (
+  eventId: string,
+  title?: string,
+) => string | null {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    (eventId: string, title?: string) => {
+      if (!store) return null;
+      return getOrCreateSessionForEventId(store, eventId, title);
+    },
+    [store],
+  );
+}
+
+export function useCreateSessionActions(): {
+  createSession: () => string | null;
+  getOrCreateSessionForEvent: (
+    eventId: string,
+    title?: string,
+  ) => string | null;
+} {
+  const createSession = useCreateSession();
+  const getOrCreateSessionForEvent = useGetOrCreateSessionForEvent();
+
+  return useMemo(
+    () => ({
+      createSession,
+      getOrCreateSessionForEvent,
+    }),
+    [createSession, getOrCreateSessionForEvent],
+  );
+}
+
+export function useCreateCountdownTestSession(): (
+  seconds: number,
+  meetingLink?: string,
+) => string | null {
+  const store = useMainStoreInternal();
+  const userId = useCurrentUserId();
+
+  return useCallback(
+    (seconds: number, meetingLink?: string) => {
+      if (!store) return null;
+      const sessionId = crypto.randomUUID();
+      const started_at = new Date(Date.now() + seconds * 1000).toISOString();
+      const event_json = JSON.stringify({
+        tracking_id: "devtool-test",
+        calendar_id: "devtool-test",
+        title: "Test Meeting",
+        started_at,
+        ended_at: new Date(
+          Date.now() + seconds * 1000 + 30 * 60 * 1000,
+        ).toISOString(),
+        is_all_day: false,
+        has_recurrence_rules: false,
+        ...(meetingLink && { meeting_link: meetingLink }),
+      });
+
+      store.setRow("sessions", sessionId, {
+        user_id: userId ?? "",
+        created_at: new Date().toISOString(),
+        title: meetingLink ? "Countdown Test (Zoom)" : "Countdown Test",
+        event_json,
+      });
+
+      return sessionId;
+    },
+    [store, userId],
+  );
+}
+
+export function useNearbyEventsForMicPrompt(): () => {
+  id: string;
+  title: string;
+}[] {
+  const eventsTable = main.UI.useTable("events", main.STORE_ID);
+
+  return useCallback(() => {
+    const now = Date.now();
+    const windowMs = 15 * 60 * 1000;
+    const results: { id: string; title: string; startedAt: number }[] = [];
+
+    for (const [eventId, event] of Object.entries(eventsTable)) {
+      if (!event?.started_at || event.is_all_day) continue;
+
+      const startTime = new Date(String(event.started_at)).getTime();
+      if (Number.isNaN(startTime)) continue;
+
+      if (Math.abs(startTime - now) <= windowMs) {
+        results.push({
+          id: eventId,
+          title: String(event.title || "Untitled Event"),
+          startedAt: startTime,
+        });
+      }
+    }
+
+    results.sort((a, b) => a.startedAt - b.startedAt);
+    return results.map(({ id, title }) => ({ id, title }));
+  }, [eventsTable]);
+}
+
+export function useApplyImportedData(): (data: unknown) => Promise<void> {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    async (data: unknown) => {
+      if (!store) {
+        throw new Error("Store not available");
+      }
+      const result = await importData(store as main.Store, data, save);
+      if (result.status === "error") {
+        throw new Error(result.error);
+      }
+    },
+    [store],
+  );
+}
diff --git a/apps/desktop/src/session/hooks/search.ts b/apps/desktop/src/session/hooks/search.ts
new file mode 100644
index 0000000000..3fa60d099f
--- /dev/null
+++ b/apps/desktop/src/session/hooks/search.ts
@@ -0,0 +1,207 @@
+import { useCallback } from "react";
+
+import { useMainStoreInternal } from "~/session/hooks/internal";
+import { getSessionEvent, getSessionSearchTimestamp } from "~/session/utils";
+
+export type ContactSearchResult = {
+  id: string;
+  name: string;
+  email: string | null;
+  jobTitle: string | null;
+  organization: string | null;
+  memo: string | null;
+};
+
+export type CalendarEventSearchResult = {
+  id: string;
+  title: string;
+  startedAt: string | null;
+  endedAt: string | null;
+  location: string | null;
+  meetingLink: string | null;
+  description: string | null;
+  participantCount: number;
+  linkedSessionId: string | null;
+};
+
+// Use imperative store reads instead of useTable so that the returned
+// callback identity stays stable across row mutations. Chat tool
+// registration depends on this stability; see useRegisterTools consumers.
+export function useContactSearchIndex(): (
+  query: string,
+  limit: number,
+) => Promise<ContactSearchResult[]> {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    async (query: string, limit: number) => {
+      if (!store) return [];
+
+      const q = query.trim().toLowerCase();
+      const rows: Array<ContactSearchResult & { createdAt: number }> = [];
+
+      store.forEachRow("humans", (rowId, _forEachCell) => {
+        const row = store.getRow("humans", rowId);
+
+        const orgId =
+          typeof row.org_id === "string" && row.org_id ? row.org_id : null;
+        const orgName =
+          orgId && store.hasRow("organizations", orgId)
+            ? ((store.getCell("organizations", orgId, "name") as
+                | string
+                | undefined) ?? null)
+            : null;
+
+        const name = typeof row.name === "string" ? row.name : "";
+        const email =
+          typeof row.email === "string" && row.email ? row.email : null;
+        const jobTitle =
+          typeof row.job_title === "string" && row.job_title
+            ? row.job_title
+            : null;
+        const memo =
+          typeof row.memo === "string" && row.memo ? row.memo : null;
+
+        const searchable = [name, email, jobTitle, memo, orgName]
+          .filter(Boolean)
+          .join("\n")
+          .toLowerCase();
+
+        if (q && !searchable.includes(q)) {
+          return;
+        }
+
+        rows.push({
+          id: rowId,
+          name,
+          email,
+          jobTitle,
+          organization: orgName,
+          memo,
+          createdAt: Date.parse((row.created_at as string) || "") || 0,
+        });
+      });
+
+      return rows
+        .sort((a, b) => b.createdAt - a.createdAt)
+        .slice(0, limit)
+        .map(({ createdAt: _createdAt, ...row }) => row);
+    },
+    [store],
+  );
+}
+
+export function useCalendarEventSearchIndex(): (
+  query: string,
+  limit: number,
+) => Promise<CalendarEventSearchResult[]> {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    async (query: string, limit: number) => {
+      if (!store) return [];
+
+      const q = query.trim().toLowerCase();
+      const sessionByTrackingId = new Map<string, string>();
+
+      store.forEachRow("sessions", (sessionId, _forEachCell) => {
+        const row = store.getRow("sessions", sessionId);
+        const event = getSessionEvent({
+          event_json:
+            typeof row.event_json === "string" ? row.event_json : undefined,
+        });
+        if (event?.tracking_id) {
+          sessionByTrackingId.set(event.tracking_id, sessionId);
+        }
+      });
+
+      const rows: Array<CalendarEventSearchResult & { startedAtMs: number }> =
+        [];
+
+      store.forEachRow("events", (eventId, _forEachCell) => {
+        const row = store.getRow("events", eventId);
+
+        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
+            : "";
+
+        let participantCount = 0;
+        if (
+          typeof row.participants_json === "string" &&
+          row.participants_json
+        ) {
+          try {
+            const parsed = JSON.parse(row.participants_json);
+            if (Array.isArray(parsed)) {
+              participantCount = parsed.length;
+            }
+          } catch {}
+        }
+
+        const searchable = [title, location, meetingLink, description]
+          .filter(Boolean)
+          .join("\n")
+          .toLowerCase();
+
+        if (q && !searchable.includes(q)) {
+          return;
+        }
+
+        rows.push({
+          id: eventId,
+          title: title || "Untitled event",
+          startedAt,
+          endedAt,
+          location,
+          meetingLink,
+          description,
+          participantCount,
+          linkedSessionId: sessionByTrackingId.get(trackingId) ?? null,
+          startedAtMs: startedAt ? Date.parse(startedAt) || 0 : 0,
+        });
+      });
+
+      return rows
+        .sort((a, b) => b.startedAtMs - a.startedAtMs)
+        .slice(0, limit)
+        .map(({ startedAtMs: _startedAtMs, ...row }) => row);
+    },
+    [store],
+  );
+}
+
+export function useSessionSearchTimestampLookup(): (
+  sessionId: string,
+) => number | undefined {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    (sessionId: string) => {
+      if (!store) return undefined;
+      return getSessionSearchTimestamp(store.getRow("sessions", sessionId));
+    },
+    [store],
+  );
+}
diff --git a/apps/desktop/src/session/hooks/sessions.ts b/apps/desktop/src/session/hooks/sessions.ts
new file mode 100644
index 0000000000..82876dc00a
--- /dev/null
+++ b/apps/desktop/src/session/hooks/sessions.ts
@@ -0,0 +1,248 @@
+import { useCallback, useMemo } from "react";
+
+import type { SessionEvent } from "@hypr/store";
+
+import {
+  useMainIndexesInternal,
+  useMainStoreInternal,
+} from "~/session/hooks/internal";
+import { getSessionEvent } from "~/session/utils";
+import { useSessionTabLifecycle as useSharedSessionTabLifecycle } from "~/shared/desktop-tab-lifecycle";
+import * as main from "~/store/tinybase/store/main";
+
+export type SessionListItem = {
+  id: string;
+  title: string;
+  createdAt: string;
+};
+
+export type SessionFolderTree = {
+  topLevel: string[];
+  byParent: Record<string, string[]>;
+};
+
+type SessionStringField =
+  | "title"
+  | "raw_md"
+  | "created_at"
+  | "event_json"
+  | "folder_id"
+  | "user_id";
+
+export function useSessionTabLifecycle(args: {
+  onEmpty?: (() => void) | null;
+  onZeroTabs?: (() => void) | null;
+}) {
+  const store = useMainStoreInternal();
+  const indexes = useMainIndexesInternal();
+
+  useSharedSessionTabLifecycle({
+    store,
+    indexes,
+    onEmpty: args.onEmpty,
+    onZeroTabs: args.onZeroTabs,
+  });
+}
+
+export function useSessionCell(
+  sessionId: string,
+  field: SessionStringField,
+): string {
+  return useSessionCellOrEmpty(sessionId, field);
+}
+
+export function useSessionCellOrEmpty(
+  sessionId: string,
+  field: SessionStringField,
+): string {
+  const v = main.UI.useCell("sessions", sessionId, field, main.STORE_ID);
+  return (v as string | undefined) ?? "";
+}
+
+export function useSessionCellOptional(
+  sessionId: string,
+  field: SessionStringField,
+): string | undefined {
+  const v = main.UI.useCell("sessions", sessionId, field, main.STORE_ID);
+  return v as string | undefined;
+}
+
+// Some header.tsx paths read fields that aren't in the schema (returns
+// undefined). Kept as a loose-typed helper so header migration can compile.
+export function useSessionUntypedCell(
+  sessionId: string,
+  field: string,
+): string | undefined {
+  const cell = main.UI.useCell(
+    "sessions",
+    sessionId,
+    field as "title",
+    main.STORE_ID,
+  );
+  return cell as string | undefined;
+}
+
+export function useAllSessionIds(): string[] {
+  return main.UI.useRowIds("sessions", main.STORE_ID);
+}
+
+export function useSession(sessionId: string) {
+  const title = main.UI.useCell("sessions", sessionId, "title", main.STORE_ID);
+  const rawMd = main.UI.useCell("sessions", sessionId, "raw_md", main.STORE_ID);
+  const createdAt = main.UI.useCell(
+    "sessions",
+    sessionId,
+    "created_at",
+    main.STORE_ID,
+  );
+  const eventJson = main.UI.useCell(
+    "sessions",
+    sessionId,
+    "event_json",
+    main.STORE_ID,
+  );
+  const folderId = main.UI.useCell(
+    "sessions",
+    sessionId,
+    "folder_id",
+    main.STORE_ID,
+  );
+
+  const event = useMemo(
+    () => getSessionEvent({ event_json: eventJson }),
+    [eventJson],
+  );
+
+  return useMemo(
+    () => ({ title, rawMd, createdAt, event, folderId }),
+    [title, rawMd, createdAt, event, folderId],
+  );
+}
+
+export function useOpenNoteSessions(): SessionListItem[] {
+  const sessionIds = useAllSessionIds();
+  const sessionsTable = main.UI.useTable("sessions", main.STORE_ID);
+
+  return useMemo(() => {
+    return sessionIds
+      .map((id) => {
+        const session = sessionsTable[id];
+        return {
+          id,
+          title:
+            typeof session?.title === "string" && session.title
+              ? session.title
+              : "Untitled",
+          createdAt:
+            typeof session?.created_at === "string" ? session.created_at : "",
+        } satisfies SessionListItem;
+      })
+      .sort((a, b) => {
+        if (!a.createdAt || !b.createdAt) return 0;
+        return (
+          new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+        );
+      });
+  }, [sessionIds, sessionsTable]);
+}
+
+export function useSessionFolderTree(): SessionFolderTree {
+  const sessionIds = useAllSessionIds();
+  const sessionsTable = main.UI.useTable("sessions", main.STORE_ID);
+
+  return useMemo(() => {
+    const allFolders = new Set<string>();
+
+    for (const id of sessionIds) {
+      const folderId = sessionsTable[id]?.folder_id;
+      if (typeof folderId !== "string" || !folderId) continue;
+
+      const parts = folderId.split("/");
+      for (let i = 1; i <= parts.length; i++) {
+        allFolders.add(parts.slice(0, i).join("/"));
+      }
+    }
+
+    const topLevel: string[] = [];
+    const byParent: Record<string, string[]> = {};
+
+    for (const folder of allFolders) {
+      const parts = folder.split("/");
+      if (parts.length === 1) {
+        topLevel.push(folder);
+      } else {
+        const parent = parts.slice(0, -1).join("/");
+        byParent[parent] = byParent[parent] || [];
+        byParent[parent].push(folder);
+      }
+    }
+
+    return {
+      topLevel: topLevel.sort(),
+      byParent: Object.fromEntries(
+        Object.entries(byParent).map(([key, value]) => [key, value.sort()]),
+      ),
+    };
+  }, [sessionIds, sessionsTable]);
+}
+
+export function useSessionEvent(sessionId: string): SessionEvent | null {
+  const eventJson = main.UI.useCell(
+    "sessions",
+    sessionId,
+    "event_json",
+    main.STORE_ID,
+  );
+  return useMemo(() => getSessionEvent({ event_json: eventJson }), [eventJson]);
+}
+
+export function useSessionIdsInFolder(folderId: string): string[] {
+  return main.UI.useSliceRowIds(
+    main.INDEXES.sessionsByFolder,
+    folderId,
+    main.STORE_ID,
+  );
+}
+
+export function useUpdateSessionCell(
+  sessionId: string,
+  field: SessionStringField,
+): (value: string) => void {
+  const store = useMainStoreInternal();
+  return useCallback(
+    (value) => {
+      if (!store) return;
+      store.setPartialRow("sessions", sessionId, {
+        [field]: value,
+      } as Record<string, string>);
+    },
+    [store, sessionId, field],
+  );
+}
+
+export function useUpdateSessionRawMd(
+  sessionId: string,
+): (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => void {
+  return main.UI.useSetPartialRowCallback(
+    "sessions",
+    sessionId,
+    (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => ({
+      raw_md: e.target.value,
+    }),
+    [],
+    main.STORE_ID,
+  );
+}
+
+export function useSetSessionCreatedAt(
+  sessionId: string,
+): (created_at: string) => void {
+  return main.UI.useSetCellCallback(
+    "sessions",
+    sessionId,
+    "created_at",
+    (created_at: string) => created_at,
+    [],
+    main.STORE_ID,
+  );
+}
diff --git a/apps/desktop/src/session/hooks/storage.test.tsx b/apps/desktop/src/session/hooks/storage.test.tsx
new file mode 100644
index 0000000000..ab55830eab
--- /dev/null
+++ b/apps/desktop/src/session/hooks/storage.test.tsx
@@ -0,0 +1,201 @@
+import { renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+type BoundaryFixture = {
+  tables: Record<string, Record<string, Record<string, unknown>>>;
+  results: Record<string, Record<string, Record<string, unknown>>>;
+  slices: Record<string, Record<string, string[]>>;
+};
+
+const { fixture, resetFixture, setFixture } = vi.hoisted(() => {
+  const fixture: BoundaryFixture = {
+    tables: {},
+    results: {},
+    slices: {},
+  };
+
+  return {
+    fixture,
+    resetFixture: () => {
+      fixture.tables = {};
+      fixture.results = {};
+      fixture.slices = {};
+    },
+    setFixture: (next: Partial<BoundaryFixture>) => {
+      fixture.tables = next.tables ?? {};
+      fixture.results = next.results ?? {};
+      fixture.slices = next.slices ?? {};
+    },
+  };
+});
+
+vi.mock("~/store/tinybase/store/main", () => {
+  const mockStore = {
+    getRow: (table: string, rowId: string) =>
+      fixture.tables[table]?.[rowId] ?? {},
+    hasRow: (table: string, rowId: string) =>
+      Boolean(fixture.tables[table]?.[rowId]),
+    getCell: (table: string, rowId: string, cell: string) =>
+      fixture.tables[table]?.[rowId]?.[cell],
+    forEachRow: (
+      table: string,
+      cb: (rowId: string, forEachCell: unknown) => void,
+    ) => {
+      for (const rowId of Object.keys(fixture.tables[table] ?? {})) {
+        cb(rowId, () => {});
+      }
+    },
+  };
+
+  return {
+    STORE_ID: "main",
+    INDEXES: {
+      transcriptBySession: "transcriptBySession",
+      enhancedNotesBySession: "enhancedNotesBySession",
+      sessionParticipantsBySession: "sessionParticipantsBySession",
+    },
+    QUERIES: {
+      sessionParticipantsWithDetails: "sessionParticipantsWithDetails",
+    },
+    UI: {
+      useCell: vi.fn(
+        (table: string, rowId: string, cell: string) =>
+          fixture.tables[table]?.[rowId]?.[cell],
+      ),
+      useSliceRowIds: vi.fn(
+        (index: string, sliceId: string) =>
+          fixture.slices[index]?.[sliceId] ?? [],
+      ),
+      useTable: vi.fn((table: string) => fixture.tables[table] ?? {}),
+      useResultTable: vi.fn((query: string) => fixture.results[query] ?? {}),
+      useStore: vi.fn(() => mockStore),
+      useIndexes: vi.fn(() => null),
+      useValue: vi.fn(() => undefined),
+      useRowIds: vi.fn((table: string) =>
+        Object.keys(fixture.tables[table] ?? {}),
+      ),
+      useResultRow: vi.fn(() => ({})),
+      useSetPartialRowCallback: vi.fn(),
+      useSetCellCallback: vi.fn(),
+      useQueries: vi.fn(() => null),
+    },
+  };
+});
+
+import {
+  useSessionParticipantNames,
+  useSearchableHumans,
+} from "./participants";
+import { useSessionSearchTimestampLookup } from "./search";
+import { useSessionCell, useSessionCellOptional } from "./sessions";
+
+describe("session hook boundaries", () => {
+  beforeEach(() => {
+    resetFixture();
+  });
+
+  it("preserves optional session cell semantics for missing values", () => {
+    const optionalResult = renderHook(() =>
+      useSessionCellOptional("session-1", "created_at"),
+    );
+    const normalizedResult = renderHook(() =>
+      useSessionCell("session-1", "created_at"),
+    );
+
+    expect(optionalResult.result.current).toBeUndefined();
+    expect(normalizedResult.result.current).toBe("");
+  });
+
+  it("returns participant names for non-excluded mappings", () => {
+    setFixture({
+      tables: {
+        mapping_session_participant: {
+          "map-1": { source: "manual" },
+          "map-2": { source: "excluded" },
+        },
+      },
+      results: {
+        sessionParticipantsWithDetails: {
+          "map-1": {
+            human_id: "human-1",
+            session_id: "session-1",
+            human_name: "Alice",
+          },
+          "map-2": {
+            human_id: "human-2",
+            session_id: "session-1",
+            human_name: "Bob",
+          },
+        },
+      },
+      slices: {
+        sessionParticipantsBySession: {
+          "session-1": ["map-1", "map-2"],
+        },
+      },
+    });
+
+    const result = renderHook(() => useSessionParticipantNames("session-1"));
+    expect(result.result.current).toEqual(["Alice"]);
+  });
+
+  it("filters humans by search text and excluded ids", () => {
+    setFixture({
+      tables: {
+        humans: {
+          "human-1": { name: "Alice", email: "alice@acme.com" },
+          "human-2": { name: "Bob", email: "bob@acme.com" },
+        },
+      },
+    });
+
+    const excluded = new Set<string>(["human-2"]);
+    const result = renderHook(() => useSearchableHumans("ali", excluded));
+
+    expect(result.result.current).toEqual([
+      {
+        id: "human-1",
+        name: "Alice",
+        email: "alice@acme.com",
+        orgId: undefined,
+        jobTitle: undefined,
+      },
+    ]);
+  });
+
+  it("prefers event start timestamps and falls back to created_at", () => {
+    setFixture({
+      tables: {
+        sessions: {
+          "session-event": {
+            created_at: "2024-01-01T00:00:00Z",
+            event_json: JSON.stringify({
+              started_at: "2024-01-15T10:00:00Z",
+            }),
+          },
+          "session-plain": {
+            created_at: "2024-02-01T00:00:00Z",
+          },
+          "session-invalid-event": {
+            created_at: "2024-03-01T00:00:00Z",
+            event_json: JSON.stringify({
+              started_at: "not-a-date",
+            }),
+          },
+        },
+      },
+    });
+
+    const result = renderHook(() => useSessionSearchTimestampLookup());
+
+    expect(result.result.current("session-event")).toBe(
+      Date.parse("2024-01-15T10:00:00Z"),
+    );
+    expect(result.result.current("session-plain")).toBe(
+      Date.parse("2024-02-01T00:00:00Z"),
+    );
+    expect(result.result.current("session-invalid-event")).toBe(
+      Date.parse("2024-03-01T00:00:00Z"),
+    );
+  });
+});
diff --git a/apps/desktop/src/session/hooks/tags.ts b/apps/desktop/src/session/hooks/tags.ts
new file mode 100644
index 0000000000..9c0eb7daba
--- /dev/null
+++ b/apps/desktop/src/session/hooks/tags.ts
@@ -0,0 +1,162 @@
+import { useCallback, useMemo } from "react";
+
+import { useMainStoreInternal } from "~/session/hooks/internal";
+import * as main from "~/store/tinybase/store/main";
+
+export function useSessionTagMappingIds(sessionId: string): string[] {
+  return main.UI.useSliceRowIds(
+    main.INDEXES.tagSessionsBySession,
+    sessionId,
+    main.STORE_ID,
+  );
+}
+
+export function useTagMappingCell(
+  mappingId: string,
+  field: "tag_id" | "session_id",
+): string {
+  const v = main.UI.useCell(
+    "mapping_tag_session",
+    mappingId,
+    field,
+    main.STORE_ID,
+  );
+  return (v as string | undefined) ?? "";
+}
+
+export function useTagName(tagId: string): string {
+  const v = main.UI.useCell("tags", tagId, "name", main.STORE_ID);
+  return (v as string | undefined) ?? "";
+}
+
+export function useSessionTagMutations(): {
+  createTag: (args: { id: string; name: string }) => void;
+  addTagToSession: (args: { tagId: string; sessionId: string }) => string;
+  deleteTagMapping: (mappingId: string) => void;
+} {
+  const store = useMainStoreInternal();
+
+  const createTag = useCallback(
+    ({ id, name }: { id: string; name: string }) => {
+      if (!store) return;
+      const userId = (store.getValue("user_id") as string | undefined) ?? "";
+      store.setRow("tags", id, { user_id: userId, name });
+    },
+    [store],
+  );
+
+  const addTagToSession = useCallback(
+    ({ tagId, sessionId }: { tagId: string; sessionId: string }) => {
+      if (!store) return "";
+      const userId = (store.getValue("user_id") as string | undefined) ?? "";
+      const mappingId = crypto.randomUUID();
+      store.setRow("mapping_tag_session", mappingId, {
+        user_id: userId,
+        tag_id: tagId,
+        session_id: sessionId,
+      });
+      return mappingId;
+    },
+    [store],
+  );
+
+  const deleteTagMapping = useCallback(
+    (mappingId: string) => {
+      if (!store) return;
+      store.delRow("mapping_tag_session", mappingId);
+    },
+    [store],
+  );
+
+  return { createTag, addTagToSession, deleteTagMapping };
+}
+
+export function useSessionTagNameMap(sessionId: string): Map<string, string> {
+  const mappingIds = useSessionTagMappingIds(sessionId);
+  const mappingTable = main.UI.useTable("mapping_tag_session", main.STORE_ID);
+  const tagsTable = main.UI.useTable("tags", main.STORE_ID);
+
+  return useMemo(() => {
+    const byName = new Map<string, string>();
+
+    for (const mappingId of mappingIds) {
+      const tagId = mappingTable[mappingId]?.tag_id;
+      if (typeof tagId !== "string" || !tagId) continue;
+
+      const tagName = tagsTable[tagId]?.name;
+      if (typeof tagName !== "string") continue;
+
+      byName.set(tagName.toLowerCase(), tagId);
+    }
+
+    return byName;
+  }, [mappingIds, mappingTable, tagsTable]);
+}
+
+export function useAddSessionTag(sessionId: string): (name: string) => void {
+  const existingTagIdsByName = useSessionTagNameMap(sessionId);
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    (name: string) => {
+      if (!store) return;
+
+      const userId = store.getValue("user_id") as string | undefined;
+      if (!userId) return;
+
+      const normalized = name.toLowerCase();
+      const existingTagId = existingTagIdsByName.get(normalized);
+
+      let tagId = existingTagId;
+      if (!tagId) {
+        let foundTagId: string | null = null;
+        store.forEachRow("tags", (rowId, _forEachCell) => {
+          if (foundTagId) return;
+
+          const tagName = store.getCell("tags", rowId, "name");
+          if (
+            typeof tagName === "string" &&
+            tagName.toLowerCase() === normalized
+          ) {
+            foundTagId = rowId;
+          }
+        });
+
+        tagId = foundTagId ?? crypto.randomUUID();
+        if (!foundTagId) {
+          store.setRow("tags", tagId, {
+            user_id: userId,
+            name,
+          });
+        }
+      }
+
+      let hasMapping = false;
+      store.forEachRow("mapping_tag_session", (mappingId, _forEachCell) => {
+        if (hasMapping) return;
+        const existingSessionId = store.getCell(
+          "mapping_tag_session",
+          mappingId,
+          "session_id",
+        );
+        const existingMappedTagId = store.getCell(
+          "mapping_tag_session",
+          mappingId,
+          "tag_id",
+        );
+        hasMapping =
+          existingSessionId === sessionId && existingMappedTagId === tagId;
+      });
+
+      if (hasMapping) return;
+
+      const mappingId = crypto.randomUUID();
+      store.setRow("mapping_tag_session", mappingId, {
+        user_id: userId,
+        tag_id: tagId,
+        session_id: sessionId,
+      });
+    },
+    [existingTagIdsByName, sessionId, store],
+  );
+}
diff --git a/apps/desktop/src/session/hooks/transcripts.ts b/apps/desktop/src/session/hooks/transcripts.ts
new file mode 100644
index 0000000000..f9c50cfac4
--- /dev/null
+++ b/apps/desktop/src/session/hooks/transcripts.ts
@@ -0,0 +1,189 @@
+import { useCallback, useMemo } from "react";
+
+import type { RenderTranscriptRequest } from "@hypr/plugin-transcription";
+
+import {
+  useCurrentUserId,
+  useMainStoreInternal,
+} from "~/session/hooks/internal";
+import * as main from "~/store/tinybase/store/main";
+import { buildRenderTranscriptRequestFromStore } from "~/stt/render-transcript";
+import {
+  defaultRenderLabelContext,
+  SpeakerLabelManager,
+} from "~/stt/segment/shared";
+import { parseTranscriptWords, upsertSpeakerAssignment } from "~/stt/utils";
+
+export function useTranscriptIdsForSession(sessionId: string): string[] {
+  return main.UI.useSliceRowIds(
+    main.INDEXES.transcriptBySession,
+    sessionId,
+    main.STORE_ID,
+  );
+}
+
+export function useTranscriptTimeRange(sessionId: string): {
+  startedAt: number | null;
+  endedAt: number | null;
+} {
+  const transcriptIds = useTranscriptIdsForSession(sessionId);
+  const transcripts = main.UI.useTable("transcripts", main.STORE_ID);
+
+  return useMemo(() => {
+    let minStartedAt: number | null = null;
+    let maxEndedAt: number | null = null;
+
+    for (const transcriptId of transcriptIds) {
+      const transcript = transcripts[transcriptId];
+      if (!transcript) continue;
+
+      const startedAt = transcript.started_at;
+      const endedAt = transcript.ended_at;
+
+      if (typeof startedAt === "number") {
+        minStartedAt =
+          minStartedAt === null ? startedAt : Math.min(minStartedAt, startedAt);
+      }
+
+      if (typeof endedAt === "number") {
+        maxEndedAt =
+          maxEndedAt === null ? endedAt : Math.max(maxEndedAt, endedAt);
+      }
+    }
+
+    return { startedAt: minStartedAt, endedAt: maxEndedAt };
+  }, [transcriptIds, transcripts]);
+}
+
+export function useTranscriptHasWords(sessionId: string): boolean {
+  const transcriptIds = useTranscriptIdsForSession(sessionId);
+  const transcriptsTable = useTranscriptsTable();
+  const store = useMainStoreInternal();
+
+  return useMemo(() => {
+    if (!store) return false;
+    return transcriptIds.some(
+      (transcriptId) => parseTranscriptWords(store, transcriptId).length > 0,
+    );
+  }, [store, transcriptIds, transcriptsTable]);
+}
+
+export function useTranscriptRenderRequest(
+  transcriptIds: string[],
+): RenderTranscriptRequest | null {
+  const store = useMainStoreInternal();
+  const transcriptsTable = useTranscriptsTable();
+  const participantMappingsTable = useParticipantMappingsTable();
+  const humansTable = useHumansTable();
+  const selfHumanId = useCurrentUserId();
+
+  return useMemo(() => {
+    if (!store || transcriptIds.length === 0) {
+      return null;
+    }
+    return buildRenderTranscriptRequestFromStore(store, transcriptIds);
+  }, [
+    store,
+    transcriptIds,
+    transcriptsTable,
+    participantMappingsTable,
+    humansTable,
+    selfHumanId,
+  ]);
+}
+
+export function useTranscriptOffsetMs(transcriptId: string): number {
+  const transcriptStartedAt = main.UI.useCell(
+    "transcripts",
+    transcriptId,
+    "started_at",
+    main.STORE_ID,
+  );
+  const sessionId = useTranscriptSessionId(transcriptId);
+  const transcriptIds = useTranscriptIdsForSession(sessionId);
+  const transcriptsTable = useTranscriptsTable();
+
+  return useMemo(() => {
+    if (typeof transcriptStartedAt !== "number") {
+      return 0;
+    }
+
+    let earliestStartedAt = Number.POSITIVE_INFINITY;
+    for (const currentTranscriptId of transcriptIds ?? []) {
+      const startedAt = transcriptsTable[currentTranscriptId]?.started_at;
+      if (typeof startedAt === "number" && startedAt < earliestStartedAt) {
+        earliestStartedAt = startedAt;
+      }
+    }
+
+    return Number.isFinite(earliestStartedAt)
+      ? transcriptStartedAt - earliestStartedAt
+      : 0;
+  }, [transcriptIds, transcriptStartedAt, transcriptsTable]);
+}
+
+export function useTranscriptLabelContext() {
+  const store = useMainStoreInternal();
+  return useMemo(
+    () => (store ? defaultRenderLabelContext(store) : undefined),
+    [store],
+  );
+}
+
+export function useTranscriptSpeakerLabelManager(
+  segments: Parameters<typeof SpeakerLabelManager.fromSegments>[0],
+): SpeakerLabelManager {
+  const labelContext = useTranscriptLabelContext();
+  return useMemo(() => {
+    if (!labelContext) {
+      return new SpeakerLabelManager();
+    }
+    return SpeakerLabelManager.fromSegments(segments, labelContext);
+  }, [labelContext, segments]);
+}
+
+export function useTranscriptsTable() {
+  return main.UI.useTable("transcripts", main.STORE_ID);
+}
+
+export function useTranscriptSessionId(transcriptId: string): string {
+  const v = main.UI.useCell(
+    "transcripts",
+    transcriptId,
+    "session_id",
+    main.STORE_ID,
+  );
+  return (v as string | undefined) ?? "";
+}
+
+export function useAssignTranscriptSpeaker(): (args: {
+  transcriptId: string;
+  segmentKey: unknown;
+  humanId: string;
+  anchorWordId: string;
+}) => void {
+  const store = useMainStoreInternal();
+
+  return useCallback(
+    ({ transcriptId, segmentKey, humanId, anchorWordId }) => {
+      if (!store) return;
+
+      upsertSpeakerAssignment(
+        store,
+        transcriptId,
+        segmentKey as Parameters<typeof upsertSpeakerAssignment>[2],
+        humanId,
+        anchorWordId,
+      );
+    },
+    [store],
+  );
+}
+
+export function useParticipantMappingsTable() {
+  return main.UI.useTable("mapping_session_participant", main.STORE_ID);
+}
+
+export function useHumansTable() {
+  return main.UI.useTable("humans", main.STORE_ID);
+}
diff --git a/apps/desktop/src/session/hooks/useEventCountdown.ts b/apps/desktop/src/session/hooks/useEventCountdown.ts
index 7f3092c02b..5ebe9d99a6 100644
--- a/apps/desktop/src/session/hooks/useEventCountdown.ts
+++ b/apps/desktop/src/session/hooks/useEventCountdown.ts
@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from "react";
 
-import { useSessionEvent } from "~/store/tinybase/hooks";
+import { useSessionEvent } from "~/session/hooks/sessions";
 
 const FIVE_MINUTES = 5 * 60 * 1000;
 
diff --git a/apps/desktop/src/session/hooks/useRemoteMeeting.ts b/apps/desktop/src/session/hooks/useRemoteMeeting.ts
index 94ca88ed73..5a8ee21a45 100644
--- a/apps/desktop/src/session/hooks/useRemoteMeeting.ts
+++ b/apps/desktop/src/session/hooks/useRemoteMeeting.ts
@@ -1,4 +1,4 @@
-import { useSessionEvent } from "~/store/tinybase/hooks";
+import { useSessionEvent } from "~/session/hooks/sessions";
 
 export type RemoteMeeting = {
   type: "zoom" | "google-meet" | "webex" | "teams";
diff --git a/apps/desktop/src/session/index.tsx b/apps/desktop/src/session/index.tsx
index 8dec70e727..c059a7fd59 100644
--- a/apps/desktop/src/session/index.tsx
+++ b/apps/desktop/src/session/index.tsx
@@ -15,6 +15,7 @@ import { SessionPreviewCard } from "./components/session-preview-card";
 import { SessionSurface } from "./components/session-surface";
 import { useCurrentNoteTab, useHasTranscript } from "./components/shared";
 import { TitleInput, type TitleInputHandle } from "./components/title-input";
+import { useSessionCell } from "./hooks/sessions";
 import { useAutoEnhance } from "./hooks/useAutoEnhance";
 import { useIsSessionEnhancing } from "./hooks/useEnhancedNotes";
 import { getSessionTabStatus } from "./tab-visual-state";
@@ -24,7 +25,6 @@ import * as AudioPlayer from "~/audio-player";
 import { useShell } from "~/contexts/shell";
 import { useSessionStatusBanner } from "~/shared/main";
 import { type TabItem, TabItemBase } from "~/shared/tabs";
-import * as main from "~/store/tinybase/store/main";
 import { useSessionTitle } from "~/store/zustand/live-title";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
 import { useListener } from "~/stt/contexts";
@@ -45,13 +45,8 @@ export const TabItemNote: TabItem<Extract<Tab, { type: "sessions" }>> = ({
   pendingCloseConfirmationTab,
   setPendingCloseConfirmationTab,
 }) => {
-  const storeTitle = main.UI.useCell(
-    "sessions",
-    tab.id,
-    "title",
-    main.STORE_ID,
-  );
-  const title = useSessionTitle(tab.id, storeTitle as string | undefined);
+  const storeTitle = useSessionCell(tab.id, "title");
+  const title = useSessionTitle(tab.id, storeTitle);
   const sessionMode = useListener((state) => state.getSessionMode(tab.id));
   const stop = useListener((state) => state.stop);
   const degraded = useListener((state) => state.live.degraded);
@@ -300,7 +295,7 @@ function useAutoFocusTitle({
   // Prevent re-focusing when the user intentionally leaves the title empty.
   const didAutoFocus = useRef(false);
 
-  const title = main.UI.useCell("sessions", sessionId, "title", main.STORE_ID);
+  const title = useSessionCell(sessionId, "title");
 
   useEffect(() => {
     if (didAutoFocus.current) return;
diff --git a/apps/desktop/src/session/utils.ts b/apps/desktop/src/session/utils.ts
index dfc27be99c..9d667bd9c2 100644
--- a/apps/desktop/src/session/utils.ts
+++ b/apps/desktop/src/session/utils.ts
@@ -16,6 +16,26 @@ export function getSessionEvent(session: {
   }
 }
 
+export function getSessionSearchTimestamp(session: {
+  created_at?: unknown;
+  event_json?: string | null;
+}): number | undefined {
+  const startedAt = getSessionEvent(session)?.started_at;
+  if (typeof startedAt === "string" && startedAt) {
+    const parsedStartedAt = Date.parse(startedAt);
+    if (!Number.isNaN(parsedStartedAt)) {
+      return parsedStartedAt;
+    }
+  }
+
+  if (typeof session.created_at !== "string" || !session.created_at) {
+    return undefined;
+  }
+
+  const parsedCreatedAt = Date.parse(session.created_at);
+  return Number.isNaN(parsedCreatedAt) ? undefined : parsedCreatedAt;
+}
+
 export function getSessionEventById(
   store: Store,
   sessionId: string,
diff --git a/apps/desktop/src/settings/data/index.tsx b/apps/desktop/src/settings/data/index.tsx
index 226d86178e..917ba3530c 100644
--- a/apps/desktop/src/settings/data/index.tsx
+++ b/apps/desktop/src/settings/data/index.tsx
@@ -13,10 +13,9 @@ import {
 import { ImportPreview } from "./import-preview";
 import { SourceItem } from "./source-item";
 
+import { useCurrentUserId } from "~/session/hooks/globals";
+import { useApplyImportedData } from "~/session/hooks/runtime";
 import { StyledStreamdown } from "~/settings/ai/shared";
-import { importData } from "~/store/tinybase/store/importer";
-import * as main from "~/store/tinybase/store/main";
-import { save } from "~/store/tinybase/store/save";
 
 type DryRunResult = {
   source: ImportSourceKind;
@@ -27,8 +26,8 @@ export function Data() {
   const [dryRunResult, setDryRunResult] = useState<DryRunResult | null>(null);
   const [successfulSource, setSuccessfulSource] =
     useState<ImportSourceKind | null>(null);
-  const store = main.UI.useStore(main.STORE_ID);
-  const { user_id } = main.UI.useValues(main.STORE_ID);
+  const user_id = useCurrentUserId();
+  const applyImportedData = useApplyImportedData();
 
   const { data: sources } = useQuery({
     queryKey: ["import-sources"],
@@ -48,18 +47,7 @@ export function Data() {
         throw new Error(result.error);
       }
 
-      if (!store) {
-        throw new Error("Store not available");
-      }
-
-      const importResult = await importData(
-        store as main.Store,
-        result.data.data,
-        save,
-      );
-      if (importResult.status === "error") {
-        throw new Error(importResult.error);
-      }
+      await applyImportedData(result.data.data);
 
       return result.data.stats;
     },
diff --git a/apps/desktop/src/settings/memory/custom-vocabulary.tsx b/apps/desktop/src/settings/memory/custom-vocabulary.tsx
index 85c56aff35..2e5418efa3 100644
--- a/apps/desktop/src/settings/memory/custom-vocabulary.tsx
+++ b/apps/desktop/src/settings/memory/custom-vocabulary.tsx
@@ -13,12 +13,7 @@ import { useMemo, useState } from "react";
 import { Button } from "@hypr/ui/components/ui/button";
 import { cn } from "@hypr/utils";
 
-import * as main from "~/store/tinybase/store/main";
-
-interface VocabItem {
-  text: string;
-  rowId: string;
-}
+import { type VocabItem, useVocabMutations, useVocabs } from "./hooks";
 
 export function CustomVocabularyView() {
   const vocabItems = useVocabs();
@@ -300,62 +295,3 @@ function VocabularyItem({
     </div>
   );
 }
-
-function useVocabs() {
-  const table = main.UI.useResultTable(
-    main.QUERIES.visibleVocabs,
-    main.STORE_ID,
-  );
-
-  return Object.entries(table ?? {}).map(
-    ([rowId, { text }]) =>
-      ({
-        rowId,
-        text,
-      }) as VocabItem,
-  );
-}
-
-function useVocabMutations() {
-  const { user_id } = main.UI.useValues(main.STORE_ID);
-
-  const createRow = main.UI.useSetRowCallback(
-    "memories",
-    () => crypto.randomUUID(),
-    (text: string) => ({
-      user_id: user_id!,
-      type: "vocab",
-      text,
-      created_at: new Date().toISOString(),
-    }),
-    [user_id],
-    main.STORE_ID,
-  );
-
-  const updateRow = main.UI.useSetPartialRowCallback(
-    "memories",
-    ({ rowId }: { rowId: string; text: string }) => rowId,
-    ({ text }: { rowId: string; text: string }) => ({ text }),
-    [],
-    main.STORE_ID,
-  ) as (args: { rowId: string; text: string }) => void;
-
-  const deleteRow = main.UI.useDelRowCallback(
-    "memories",
-    (rowId: string) => rowId,
-    main.STORE_ID,
-  );
-
-  return {
-    create: (text: string) => {
-      if (!user_id) return;
-      createRow(text);
-    },
-    update: (rowId: string, text: string) => {
-      updateRow({ rowId, text });
-    },
-    delete: (rowId: string) => {
-      deleteRow(rowId);
-    },
-  };
-}
diff --git a/apps/desktop/src/settings/memory/hooks.ts b/apps/desktop/src/settings/memory/hooks.ts
new file mode 100644
index 0000000000..b8b14ecfd0
--- /dev/null
+++ b/apps/desktop/src/settings/memory/hooks.ts
@@ -0,0 +1,70 @@
+import * as main from "~/store/tinybase/store/main";
+
+// Storage boundary for memory/vocabulary UI. Keep this API independent from
+// the underlying persistence implementation.
+export type VocabItem = {
+  rowId: string;
+  text: string;
+};
+
+export type VocabMutations = {
+  create: (text: string) => void;
+  update: (rowId: string, text: string) => void;
+  delete: (rowId: string) => void;
+};
+
+export function useVocabs(): VocabItem[] {
+  const table = main.UI.useResultTable(
+    main.QUERIES.visibleVocabs,
+    main.STORE_ID,
+  );
+
+  return Object.entries(table ?? {}).map(([rowId, { text }]) => ({
+    rowId,
+    text: (text as string | undefined) ?? "",
+  }));
+}
+
+export function useVocabMutations(): VocabMutations {
+  const { user_id } = main.UI.useValues(main.STORE_ID);
+
+  const createRow = main.UI.useSetRowCallback(
+    "memories",
+    () => crypto.randomUUID(),
+    (text: string) => ({
+      user_id: user_id!,
+      type: "vocab",
+      text,
+      created_at: new Date().toISOString(),
+    }),
+    [user_id],
+    main.STORE_ID,
+  );
+
+  const updateRow = main.UI.useSetPartialRowCallback(
+    "memories",
+    ({ rowId }: { rowId: string; text: string }) => rowId,
+    ({ text }: { rowId: string; text: string }) => ({ text }),
+    [],
+    main.STORE_ID,
+  ) as (args: { rowId: string; text: string }) => void;
+
+  const deleteRow = main.UI.useDelRowCallback(
+    "memories",
+    (rowId: string) => rowId,
+    main.STORE_ID,
+  );
+
+  return {
+    create: (text: string) => {
+      if (!user_id) return;
+      createRow(text);
+    },
+    update: (rowId: string, text: string) => {
+      updateRow({ rowId, text });
+    },
+    delete: (rowId: string) => {
+      deleteRow(rowId);
+    },
+  };
+}
diff --git a/apps/desktop/src/shared/desktop-tab-lifecycle.ts b/apps/desktop/src/shared/desktop-tab-lifecycle.ts
index 789f7ba88c..449eaf5507 100644
--- a/apps/desktop/src/shared/desktop-tab-lifecycle.ts
+++ b/apps/desktop/src/shared/desktop-tab-lifecycle.ts
@@ -144,3 +144,22 @@ export function useDesktopTabLifecycle({
     );
   }, [indexes, registerOnClose, store]);
 }
+
+export function useSessionTabLifecycle({
+  store,
+  indexes,
+  onEmpty,
+  onZeroTabs,
+}: {
+  store: SessionStore | null | undefined;
+  indexes: SessionIndexes | null | undefined;
+  onEmpty?: (() => void) | null;
+  onZeroTabs?: (() => void) | null;
+}) {
+  useDesktopTabLifecycle({
+    store,
+    indexes,
+    onEmpty,
+    onZeroTabs,
+  });
+}
diff --git a/apps/desktop/src/shared/open-note-dialog.tsx b/apps/desktop/src/shared/open-note-dialog.tsx
index dea7292671..72834c311b 100644
--- a/apps/desktop/src/shared/open-note-dialog.tsx
+++ b/apps/desktop/src/shared/open-note-dialog.tsx
@@ -6,7 +6,7 @@ import { createPortal } from "react-dom";
 import { Kbd } from "@hypr/ui/components/ui/kbd";
 import { cn } from "@hypr/utils";
 
-import * as main from "~/store/tinybase/store/main";
+import { useOpenNoteSessions } from "~/session/hooks/sessions";
 import { useTabs } from "~/store/zustand/tabs";
 
 const MAX_RECENT_DISPLAY = 5;
@@ -30,29 +30,16 @@ export function OpenNoteDialog({ open, onOpenChange }: OpenNoteDialogProps) {
     (state) => state.recentlyOpenedSessionIds,
   );
 
-  const sessionIds = main.UI.useRowIds("sessions", main.STORE_ID);
-  const store = main.UI.useStore(main.STORE_ID);
+  const sessions = useOpenNoteSessions();
 
-  const sessionsMap = useMemo(() => {
-    if (!store || !sessionIds) return new Map<string, Session>();
-
-    const map = new Map<string, Session>();
-    for (const id of sessionIds) {
-      map.set(id, {
-        id,
-        title: (store.getCell("sessions", id, "title") as string) || "Untitled",
-        createdAt: store.getCell("sessions", id, "created_at") as string,
-      });
-    }
-    return map;
-  }, [sessionIds, store]);
+  const sessionsMap = useMemo(
+    () => new Map(sessions.map((session) => [session.id, session])),
+    [sessions],
+  );
 
   const allSessionsSortedByDate = useMemo(() => {
-    return Array.from(sessionsMap.values()).sort((a, b) => {
-      if (!a.createdAt || !b.createdAt) return 0;
-      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
-    });
-  }, [sessionsMap]);
+    return sessions;
+  }, [sessions]);
 
   const recentSessions = useMemo(() => {
     return recentlyOpenedSessionIds
diff --git a/apps/desktop/src/sidebar/contacts.tsx b/apps/desktop/src/sidebar/contacts.tsx
index 8e137b2884..2f9c7009ae 100644
--- a/apps/desktop/src/sidebar/contacts.tsx
+++ b/apps/desktop/src/sidebar/contacts.tsx
@@ -4,17 +4,22 @@ import { useHotkeys } from "react-hotkeys-hook";
 
 import type { ContactsSelection } from "@hypr/plugin-windows";
 
+import {
+  type PinnedContactItem,
+  useDeleteHuman,
+  useDeleteOrganization,
+  useHumansByIds,
+  useOrganizationsByIds,
+  useReorderPinnedContacts,
+  useSortedVisibleHumanIds,
+  useSortedVisibleOrganizationIds,
+} from "~/contacts/hooks";
 import { NewPersonForm } from "~/contacts/new-person-form";
 import { OrganizationItem } from "~/contacts/organization-item";
 import { PersonItem } from "~/contacts/person-item";
 import { ColumnHeader, type SortOption } from "~/contacts/shared";
-import * as main from "~/store/tinybase/store/main";
 import { useTabs } from "~/store/zustand/tabs";
 
-type ContactItem =
-  | { kind: "person"; id: string }
-  | { kind: "organization"; id: string };
-
 export function ContactsNav() {
   const currentTab = useTabs((state) => state.currentTab);
   const updateContactsTabState = useTabs(
@@ -34,34 +39,26 @@ export function ContactsNav() {
     [currentTab, updateContactsTabState],
   );
 
-  const deletePersonFromStore = main.UI.useDelRowCallback(
-    "humans",
-    (human_id: string) => human_id,
-    main.STORE_ID,
-  );
+  const deletePerson = useDeleteHuman();
 
   const handleDeletePerson = useCallback(
     (id: string) => {
       invalidateResource("humans", id);
-      deletePersonFromStore(id);
+      deletePerson(id);
       setSelected(null);
     },
-    [invalidateResource, deletePersonFromStore, setSelected],
+    [invalidateResource, deletePerson, setSelected],
   );
 
-  const deleteOrganizationFromStore = main.UI.useDelRowCallback(
-    "organizations",
-    (org_id: string) => org_id,
-    main.STORE_ID,
-  );
+  const deleteOrganization = useDeleteOrganization();
 
   const handleDeleteOrganization = useCallback(
     (id: string) => {
       invalidateResource("organizations" as const, id);
-      deleteOrganizationFromStore(id);
+      deleteOrganization(id);
       setSelected(null);
     },
-    [invalidateResource, deleteOrganizationFromStore, setSelected],
+    [invalidateResource, deleteOrganization, setSelected],
   );
 
   return (
@@ -100,75 +97,18 @@ function ContactsList({
     [],
   );
 
-  const allHumans = main.UI.useTable("humans", main.STORE_ID);
-  const allOrgs = main.UI.useTable("organizations", main.STORE_ID);
-  const store = main.UI.useStore(main.STORE_ID);
+  const alphabeticalHumanIds = useSortedVisibleHumanIds("name", false);
+  const reverseAlphabeticalHumanIds = useSortedVisibleHumanIds("name", true);
+  const newestHumanIds = useSortedVisibleHumanIds("created_at", true);
+  const oldestHumanIds = useSortedVisibleHumanIds("created_at", false);
 
-  const alphabeticalHumanIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleHumans,
-    "name",
-    false,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-  const reverseAlphabeticalHumanIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleHumans,
+  const alphabeticalOrgIds = useSortedVisibleOrganizationIds("name", false);
+  const reverseAlphabeticalOrgIds = useSortedVisibleOrganizationIds(
     "name",
     true,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-  const newestHumanIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleHumans,
-    "created_at",
-    true,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-  const oldestHumanIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleHumans,
-    "created_at",
-    false,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-
-  const alphabeticalOrgIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleOrganizations,
-    "name",
-    false,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-  const reverseAlphabeticalOrgIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleOrganizations,
-    "name",
-    true,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-  const newestOrgIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleOrganizations,
-    "created_at",
-    true,
-    0,
-    undefined,
-    main.STORE_ID,
-  );
-  const oldestOrgIds = main.UI.useResultSortedRowIds(
-    main.QUERIES.visibleOrganizations,
-    "created_at",
-    false,
-    0,
-    undefined,
-    main.STORE_ID,
   );
+  const newestOrgIds = useSortedVisibleOrganizationIds("created_at", true);
+  const oldestOrgIds = useSortedVisibleOrganizationIds("created_at", false);
 
   const sortedHumanIds =
     sortOption === "alphabetical"
@@ -188,15 +128,17 @@ function ContactsList({
           ? newestOrgIds
           : oldestOrgIds;
 
+  const allHumans = useHumansByIds(sortedHumanIds);
+  const allOrgs = useOrganizationsByIds(sortedOrgIds);
+  const reorderPinned = useReorderPinnedContacts();
+
   const { pinnedHumanIds, unpinnedHumanIds } = useMemo(() => {
     const pinned = sortedHumanIds.filter((id) => allHumans[id]?.pinned);
     const unpinned = sortedHumanIds.filter((id) => !allHumans[id]?.pinned);
 
     const sortedPinned = [...pinned].sort((a, b) => {
-      const orderA =
-        (allHumans[a]?.pin_order as number | undefined) ?? Infinity;
-      const orderB =
-        (allHumans[b]?.pin_order as number | undefined) ?? Infinity;
+      const orderA = allHumans[a]?.pinOrder ?? Infinity;
+      const orderB = allHumans[b]?.pinOrder ?? Infinity;
       return orderA - orderB;
     });
 
@@ -208,8 +150,8 @@ function ContactsList({
     const unpinned = sortedOrgIds.filter((id) => !allOrgs[id]?.pinned);
 
     const sortedPinned = [...pinned].sort((a, b) => {
-      const orderA = (allOrgs[a]?.pin_order as number | undefined) ?? Infinity;
-      const orderB = (allOrgs[b]?.pin_order as number | undefined) ?? Infinity;
+      const orderA = allOrgs[a]?.pinOrder ?? Infinity;
+      const orderB = allOrgs[b]?.pinOrder ?? Infinity;
       return orderA - orderB;
     });
 
@@ -237,22 +179,22 @@ function ContactsList({
       ...pinnedHumanIds.filter(filterHuman).map((id) => ({
         kind: "person" as const,
         id,
-        pin_order: (allHumans[id]?.pin_order as number | undefined) ?? Infinity,
+        pinOrder: allHumans[id]?.pinOrder ?? Infinity,
       })),
       ...pinnedOrgIds.filter(filterOrg).map((id) => ({
         kind: "organization" as const,
         id,
-        pin_order: (allOrgs[id]?.pin_order as number | undefined) ?? Infinity,
+        pinOrder: allOrgs[id]?.pinOrder ?? Infinity,
       })),
     ]
-      .sort((a, b) => a.pin_order - b.pin_order)
+      .sort((a, b) => a.pinOrder - b.pinOrder)
       .map(({ kind, id }) => ({ kind, id }));
 
-    const unpinnedOrgs: ContactItem[] = unpinnedOrgIds
+    const unpinnedOrgs: PinnedContactItem[] = unpinnedOrgIds
       .filter(filterOrg)
       .map((id) => ({ kind: "organization" as const, id }));
 
-    const unpinnedPeople: ContactItem[] = unpinnedHumanIds
+    const unpinnedPeople: PinnedContactItem[] = unpinnedHumanIds
       .filter(filterHuman)
       .map((id) => ({ kind: "person" as const, id }));
 
@@ -272,26 +214,21 @@ function ContactsList({
 
   const handleReorderPinned = useCallback(
     (newOrder: string[]) => {
-      if (!store) return;
-      store.transaction(() => {
-        newOrder.forEach((id, index) => {
-          const item = pinnedItems.find((i) => i.id === id);
-          if (item?.kind === "person") {
-            store.setCell("humans", id, "pin_order", index);
-          } else if (item?.kind === "organization") {
-            store.setCell("organizations", id, "pin_order", index);
-          }
-        });
-      });
+      const ordered: PinnedContactItem[] = [];
+      for (const id of newOrder) {
+        const item = pinnedItems.find((i) => i.id === id);
+        if (item) ordered.push(item);
+      }
+      reorderPinned(ordered);
     },
-    [store, pinnedItems],
+    [reorderPinned, pinnedItems],
   );
 
   const handleAdd = useCallback(() => {
     setShowNewPerson(true);
   }, []);
 
-  const isActive = (item: ContactItem) => {
+  const isActive = (item: PinnedContactItem) => {
     if (!selected) return false;
     return selected.type === item.kind && selected.id === item.id;
   };
diff --git a/apps/desktop/src/sidebar/devtool.tsx b/apps/desktop/src/sidebar/devtool.tsx
index dadf755567..3bc4df835b 100644
--- a/apps/desktop/src/sidebar/devtool.tsx
+++ b/apps/desktop/src/sidebar/devtool.tsx
@@ -7,7 +7,7 @@ import {
 import { cn } from "@hypr/utils";
 
 import { getLatestVersion } from "~/changelog";
-import * as main from "~/store/tinybase/store/main";
+import { useCreateCountdownTestSession } from "~/session/hooks/runtime";
 import { useTabs } from "~/store/zustand/tabs";
 import { commands } from "~/types/tauri.gen";
 
@@ -188,38 +188,16 @@ function ToastsCard() {
 }
 
 function CountdownTestCard() {
-  const store = main.UI.useStore(main.STORE_ID) as main.Store | undefined;
-  const { user_id } = main.UI.useValues(main.STORE_ID);
+  const createCountdownTestSession = useCreateCountdownTestSession();
   const openNew = useTabs((s) => s.openNew);
 
   const createWithCountdown = useCallback(
     (seconds: number, meetingLink?: string) => {
-      if (!store) return;
-      const sessionId = crypto.randomUUID();
-      const started_at = new Date(Date.now() + seconds * 1000).toISOString();
-      const event_json = JSON.stringify({
-        tracking_id: "devtool-test",
-        calendar_id: "devtool-test",
-        title: "Test Meeting",
-        started_at,
-        ended_at: new Date(
-          Date.now() + seconds * 1000 + 30 * 60 * 1000,
-        ).toISOString(),
-        is_all_day: false,
-        has_recurrence_rules: false,
-        ...(meetingLink && { meeting_link: meetingLink }),
-      });
-
-      store.setRow("sessions", sessionId, {
-        user_id: user_id ?? "",
-        created_at: new Date().toISOString(),
-        title: meetingLink ? "Countdown Test (Zoom)" : "Countdown Test",
-        event_json,
-      });
-
+      const sessionId = createCountdownTestSession(seconds, meetingLink);
+      if (!sessionId) return;
       openNew({ type: "sessions", id: sessionId });
     },
-    [store, user_id, openNew],
+    [createCountdownTestSession, openNew],
   );
 
   const btnClass = cn([
@@ -236,7 +214,6 @@ function CountdownTestCard() {
       <div className="flex flex-col gap-1.5">
         <button
           type="button"
-          disabled={!store}
           onClick={() => createWithCountdown(20)}
           className={btnClass}
         >
@@ -244,7 +221,6 @@ function CountdownTestCard() {
         </button>
         <button
           type="button"
-          disabled={!store}
           onClick={() => createWithCountdown(60)}
           className={btnClass}
         >
@@ -252,7 +228,6 @@ function CountdownTestCard() {
         </button>
         <button
           type="button"
-          disabled={!store}
           onClick={() => createWithCountdown(290)}
           className={btnClass}
         >
@@ -261,7 +236,6 @@ function CountdownTestCard() {
         <hr className="border-neutral-100" />
         <button
           type="button"
-          disabled={!store}
           onClick={() =>
             createWithCountdown(20, "https://zoom.us/j/1234567890")
           }
@@ -271,7 +245,6 @@ function CountdownTestCard() {
         </button>
         <button
           type="button"
-          disabled={!store}
           onClick={() =>
             createWithCountdown(60, "https://zoom.us/j/1234567890")
           }
diff --git a/apps/desktop/src/sidebar/profile/index.tsx b/apps/desktop/src/sidebar/profile/index.tsx
index 4dc54a2bf5..73e42610a6 100644
--- a/apps/desktop/src/sidebar/profile/index.tsx
+++ b/apps/desktop/src/sidebar/profile/index.tsx
@@ -21,8 +21,9 @@ import { MenuItem, ProfileFacehash } from "./shared";
 
 import { useAuth } from "~/auth";
 import { useBillingAccess } from "~/auth/billing";
+import { useHumanCell } from "~/contacts/hooks";
+import { useCurrentUserId } from "~/session/hooks/globals";
 import { useAutoCloser } from "~/shared/hooks/useAutoCloser";
-import * as main from "~/store/tinybase/store/main";
 import { useTabs } from "~/store/zustand/tabs";
 
 type ProfileView = "main" | "notifications";
@@ -321,7 +322,7 @@ function ProfileButton({
 }
 
 function useMyName(email?: string) {
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
-  const name = main.UI.useCell("humans", userId ?? "", "name", main.STORE_ID);
+  const userId = useCurrentUserId();
+  const name = useHumanCell(userId ?? "", "name");
   return name || email || "Unknown";
 }
diff --git a/apps/desktop/src/sidebar/settings.tsx b/apps/desktop/src/sidebar/settings.tsx
index c09873e00e..ad9337b84c 100644
--- a/apps/desktop/src/sidebar/settings.tsx
+++ b/apps/desktop/src/sidebar/settings.tsx
@@ -10,6 +10,7 @@ import {
   CodeIcon,
   FlaskConical,
   LockIcon,
+  MicIcon,
   SmartphoneIcon,
   SparklesIcon,
   TicketIcon,
@@ -61,6 +62,7 @@ function getBaseGroups() {
         { id: "lab", label: "General", icon: FlaskConical },
         { id: "agent", label: "Agent", icon: BotIcon },
         { id: "developer", label: "Developer", icon: CodeIcon },
+        { id: "dictation", label: "Dictation", icon: MicIcon },
         { id: "todo", label: "Ticket", icon: TicketIcon },
       ],
     },
diff --git a/apps/desktop/src/sidebar/timeline/index.tsx b/apps/desktop/src/sidebar/timeline/index.tsx
index e03fdf8aa3..a9012a342d 100644
--- a/apps/desktop/src/sidebar/timeline/index.tsx
+++ b/apps/desktop/src/sidebar/timeline/index.tsx
@@ -7,7 +7,6 @@ import {
   useState,
 } from "react";
 
-import { commands as fsSyncCommands } from "@hypr/plugin-fs-sync";
 import { Button } from "@hypr/ui/components/ui/button";
 import { cn, startOfDay } from "@hypr/utils";
 
@@ -32,14 +31,14 @@ import {
   type TimelineSessionsTable,
 } from "./utils";
 
+import { useIgnoredEvents } from "~/calendar/hooks";
+import {
+  useTimelineEventMap,
+  useTimelineSessionMap,
+} from "~/session/hooks/queries";
+import { useDeleteSessionsWithUndo } from "~/session/hooks/runtime";
 import { useConfigValue } from "~/shared/config";
 import { useNativeContextMenu } from "~/shared/hooks/useNativeContextMenu";
-import { useIgnoredEvents } from "~/store/tinybase/hooks";
-import {
-  captureSessionData,
-  deleteSessionCascade,
-} from "~/store/tinybase/store/deleteSession";
-import * as main from "~/store/tinybase/store/main";
 import { useTabs } from "~/store/zustand/tabs";
 import { useTimelineSelection } from "~/store/zustand/timeline-selection";
 import { useUndoDelete } from "~/store/zustand/undo-delete";
@@ -68,10 +67,15 @@ export function TimelineView() {
         ...bucket,
         items: bucket.items.filter((item) => {
           if (item.type !== "event") return true;
-          return !isIgnored(
-            item.data.tracking_id_event,
-            item.data.recurrence_series_id,
-          );
+          const trackingId =
+            "trackingIdEvent" in item.data
+              ? item.data.trackingIdEvent
+              : item.data.tracking_id_event;
+          const recurrenceSeriesId =
+            "recurrenceSeriesId" in item.data
+              ? item.data.recurrenceSeriesId
+              : item.data.recurrence_series_id;
+          return !isIgnored(trackingId, recurrenceSeriesId);
         }),
       }))
       .filter((bucket) => bucket.items.length > 0);
@@ -83,10 +87,17 @@ export function TimelineView() {
     }
 
     return Object.fromEntries(
-      Object.entries(timelineEventsTable).filter(
-        ([, item]) =>
-          !isIgnored(item.tracking_id_event, item.recurrence_series_id),
-      ),
+      Object.entries(timelineEventsTable).filter(([, item]) => {
+        const trackingId =
+          "trackingIdEvent" in item
+            ? item.trackingIdEvent
+            : item.tracking_id_event;
+        const recurrenceSeriesId =
+          "recurrenceSeriesId" in item
+            ? item.recurrenceSeriesId
+            : item.recurrence_series_id;
+        return !isIgnored(trackingId, recurrenceSeriesId);
+      }),
     );
   }, [timelineEventsTable, showIgnored, isIgnored]);
 
@@ -127,13 +138,11 @@ export function TimelineView() {
     return currentTab?.type === "sessions" ? currentTab.id : undefined;
   }, [currentTab]);
 
-  const store = main.UI.useStore(main.STORE_ID);
-
   const selectedIds = useTimelineSelection((s) => s.selectedIds);
   const clearSelection = useTimelineSelection((s) => s.clear);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
   const invalidateResource = useTabs((state) => state.invalidateResource);
   const addDeletion = useUndoDelete((state) => state.addDeletion);
+  const deleteSessionsWithUndo = useDeleteSessionsWithUndo();
 
   const flatItemKeys = useMemo(() => {
     const keys: string[] = [];
@@ -213,40 +222,24 @@ export function TimelineView() {
   }, [openNew]);
 
   const handleDeleteSelected = useCallback(() => {
-    if (!store || !indexes) {
-      return;
-    }
-
     const sessionIds = selectedIds
       .filter((key) => key.startsWith("session-"))
       .map((key) => key.replace("session-", ""));
 
     const batchId = sessionIds.length > 1 ? crypto.randomUUID() : undefined;
 
-    for (const sessionId of sessionIds) {
-      const capturedData = captureSessionData(store, indexes, sessionId);
-
-      invalidateResource("sessions", sessionId);
-      void deleteSessionCascade(store, indexes, sessionId, {
-        skipAudio: true,
-      });
-
-      if (capturedData) {
-        addDeletion(
-          capturedData,
-          () => {
-            void fsSyncCommands.audioDelete(sessionId);
-          },
-          batchId,
-        );
-      }
-    }
+    deleteSessionsWithUndo({
+      sessionIds,
+      invalidateSessionResource: (sessionId) =>
+        invalidateResource("sessions", sessionId),
+      addDeletion,
+      batchId,
+    });
 
     clearSelection();
   }, [
-    store,
-    indexes,
     selectedIds,
+    deleteSessionsWithUndo,
     invalidateResource,
     addDeletion,
     clearSelection,
@@ -549,14 +542,8 @@ function useTimelineTables(): {
   timelineEventsTable: TimelineEventsTable;
   timelineSessionsTable: TimelineSessionsTable;
 } {
-  const timelineEventsTable = main.UI.useResultTable(
-    main.QUERIES.timelineEvents,
-    main.STORE_ID,
-  );
-  const timelineSessionsTable = main.UI.useResultTable(
-    main.QUERIES.timelineSessions,
-    main.STORE_ID,
-  );
+  const timelineEventsTable = useTimelineEventMap();
+  const timelineSessionsTable = useTimelineSessionMap();
 
   return { timelineEventsTable, timelineSessionsTable };
 }
diff --git a/apps/desktop/src/sidebar/timeline/item.tsx b/apps/desktop/src/sidebar/timeline/item.tsx
index cc67ee635c..f706be3492 100644
--- a/apps/desktop/src/sidebar/timeline/item.tsx
+++ b/apps/desktop/src/sidebar/timeline/item.tsx
@@ -18,18 +18,17 @@ import {
   TimelinePrecision,
 } from "./utils";
 
+import { useCalendar, useIgnoredEvents } from "~/calendar/hooks";
 import { SessionPreviewCard } from "~/session/components/session-preview-card";
+import {
+  useDeleteSessionsWithUndo,
+  useGetOrCreateSessionForEvent,
+} from "~/session/hooks/runtime";
+import { useSessionCell } from "~/session/hooks/sessions";
 import { useIsSessionEnhancing } from "~/session/hooks/useEnhancedNotes";
 import { getSessionEvent } from "~/session/utils";
 import type { MenuItemDef } from "~/shared/hooks/useNativeContextMenu";
 import { InteractiveButton } from "~/shared/ui/interactive-button";
-import { useIgnoredEvents } from "~/store/tinybase/hooks";
-import {
-  captureSessionData,
-  deleteSessionCascade,
-} from "~/store/tinybase/store/deleteSession";
-import * as main from "~/store/tinybase/store/main";
-import { getOrCreateSessionForEventId } from "~/store/tinybase/store/sessions";
 import { useSessionTitle } from "~/store/zustand/live-title";
 import { type TabInput, useTabs } from "~/store/zustand/tabs";
 import { useTimelineSelection } from "~/store/zustand/timeline-selection";
@@ -165,15 +164,24 @@ const EventItem = memo(
     multiSelected: boolean;
     flatItemKeys: string[];
   }) => {
-    const store = main.UI.useStore(main.STORE_ID);
+    const getOrCreateSessionForEvent = useGetOrCreateSessionForEvent();
     const openCurrent = useTabs((state) => state.openCurrent);
     const openNew = useTabs((state) => state.openNew);
 
     const eventId = item.id;
-    const trackingIdEvent = item.data.tracking_id_event;
+    const trackingIdEvent =
+      "trackingIdEvent" in item.data
+        ? item.data.trackingIdEvent
+        : item.data.tracking_id_event;
     const title = item.data.title || "Untitled";
-    const calendarId = item.data.calendar_id ?? null;
-    const recurrenceSeriesId = item.data.recurrence_series_id;
+    const calendarId =
+      "calendarId" in item.data
+        ? (item.data.calendarId ?? null)
+        : (item.data.calendar_id ?? null);
+    const recurrenceSeriesId =
+      "recurrenceSeriesId" in item.data
+        ? item.data.recurrenceSeriesId
+        : item.data.recurrence_series_id;
 
     const {
       isIgnored,
@@ -186,21 +194,29 @@ const EventItem = memo(
     const ignored = isIgnored(trackingIdEvent, recurrenceSeriesId);
 
     const displayTime = useMemo(
-      () => formatDisplayTime(item.data.started_at, precision, timezone),
-      [item.data.started_at, precision, timezone],
+      () =>
+        formatDisplayTime(
+          "startedAt" in item.data ? item.data.startedAt : item.data.started_at,
+          precision,
+          timezone,
+        ),
+      [item.data, precision, timezone],
     );
 
     const openEvent = useCallback(
       (openInNewTab: boolean) => {
-        if (!store || !eventId) {
+        if (!eventId) {
           return;
         }
 
-        const sessionId = getOrCreateSessionForEventId(store, eventId, title);
+        const sessionId = getOrCreateSessionForEvent(eventId, title);
+        if (!sessionId) {
+          return;
+        }
         const tab: TabInput = { id: sessionId, type: "sessions" };
         openInNewTab ? openNew(tab) : openCurrent(tab);
       },
-      [eventId, store, title, openCurrent, openNew],
+      [eventId, getOrCreateSessionForEvent, title, openCurrent, openNew],
     );
 
     const itemKey = `event-${item.id}`;
@@ -326,8 +342,7 @@ const SessionItem = memo(
     multiSelected: boolean;
     flatItemKeys: string[];
   }) => {
-    const store = main.UI.useStore(main.STORE_ID);
-    const indexes = main.UI.useIndexes(main.STORE_ID);
+    const deleteSessionsWithUndo = useDeleteSessionsWithUndo();
     const openCurrent = useTabs((state) => state.openCurrent);
     const openNew = useTabs((state) => state.openNew);
     const invalidateResource = useTabs((state) => state.invalidateResource);
@@ -335,12 +350,7 @@ const SessionItem = memo(
     const { ignoreEvent } = useIgnoredEvents();
 
     const sessionId = item.id;
-    const storeTitle = main.UI.useCell(
-      "sessions",
-      sessionId,
-      "title",
-      main.STORE_ID,
-    ) as string | undefined;
+    const storeTitle = useSessionCell(sessionId, "title");
     const title = useSessionTitle(sessionId, storeTitle);
 
     const sessionMode = useListener((state) => state.getSessionMode(sessionId));
@@ -350,21 +360,21 @@ const SessionItem = memo(
     const showSpinner =
       !selected && (isFinalizing || isEnhancing || isBatching);
 
-    const sessionEvent = useMemo(
-      () => getSessionEvent(item.data),
-      [item.data.event_json],
-    );
+    const sessionEvent =
+      "event" in item.data ? item.data.event : getSessionEvent(item.data);
+    const sessionCreatedAt =
+      "createdAt" in item.data ? item.data.createdAt : item.data.created_at;
 
     const calendarId = sessionEvent?.calendar_id ?? null;
 
     const displayTime = useMemo(
       () =>
         formatDisplayTime(
-          sessionEvent?.started_at ?? item.data.created_at,
+          sessionEvent?.started_at ?? sessionCreatedAt,
           precision,
           timezone,
         ),
-      [sessionEvent?.started_at, item.data.created_at, precision, timezone],
+      [sessionEvent?.started_at, sessionCreatedAt, precision, timezone],
     );
     const muted = isTimelineItemInFuture(item);
 
@@ -388,32 +398,20 @@ const SessionItem = memo(
     }, [sessionId, openNew]);
 
     const handleDelete = useCallback(() => {
-      if (!store) {
-        return;
-      }
-
       if (sessionEvent?.tracking_id) {
         ignoreEvent(sessionEvent.tracking_id);
       }
 
-      const capturedData = captureSessionData(store, indexes, sessionId);
-
-      invalidateResource("sessions", sessionId);
-      void deleteSessionCascade(store, indexes, sessionId, {
-        skipAudio: true,
+      deleteSessionsWithUndo({
+        sessionIds: [sessionId],
+        invalidateSessionResource: (id) => invalidateResource("sessions", id),
+        addDeletion,
       });
-
-      if (capturedData) {
-        addDeletion(capturedData, () => {
-          void fsSyncCommands.audioDelete(sessionId);
-        });
-      }
     }, [
-      store,
-      indexes,
       sessionId,
       sessionEvent,
       ignoreEvent,
+      deleteSessionsWithUndo,
       invalidateResource,
       addDeletion,
     ]);
@@ -498,10 +496,10 @@ function formatDisplayTime(
 }
 
 function CalendarIndicator({ calendarId }: { calendarId: string }) {
-  const calendar = main.UI.useRow("calendars", calendarId, main.STORE_ID);
+  const calendar = useCalendar(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/sidebar/timeline/realtime.tsx b/apps/desktop/src/sidebar/timeline/realtime.tsx
index da2d795751..41161b2833 100644
--- a/apps/desktop/src/sidebar/timeline/realtime.tsx
+++ b/apps/desktop/src/sidebar/timeline/realtime.tsx
@@ -80,8 +80,12 @@ export function useSmartCurrentTime(
 
       if (eventsTable) {
         Object.values(eventsTable).forEach((event) => {
-          const startTime = safeParseDate(event.started_at);
-          const endTime = safeParseDate(event.ended_at);
+          const startTime = safeParseDate(
+            "startedAt" in event ? event.startedAt : event.started_at,
+          );
+          const endTime = safeParseDate(
+            "endedAt" in event ? event.endedAt : event.ended_at,
+          );
 
           if (startTime && startTime.getTime() > currentTime) {
             importantTimes.push(startTime.getTime());
@@ -94,8 +98,18 @@ export function useSmartCurrentTime(
 
       if (sessionsTable) {
         Object.values(sessionsTable).forEach((session) => {
+          const sessionEvent =
+            "event" in session
+              ? session.event
+              : getSessionEvent({
+                  event_json:
+                    typeof session.event_json === "string"
+                      ? session.event_json
+                      : undefined,
+                });
           const time = safeParseDate(
-            getSessionEvent(session)?.started_at ?? session.created_at,
+            sessionEvent?.started_at ??
+              ("createdAt" in session ? session.createdAt : session.created_at),
           );
           if (time && time.getTime() > currentTime) {
             importantTimes.push(time.getTime());
diff --git a/apps/desktop/src/sidebar/timeline/utils/index.ts b/apps/desktop/src/sidebar/timeline/utils/index.ts
index 09f75cbf3f..8b5c3131b6 100644
--- a/apps/desktop/src/sidebar/timeline/utils/index.ts
+++ b/apps/desktop/src/sidebar/timeline/utils/index.ts
@@ -8,31 +8,37 @@ import {
   TZDate,
 } from "@hypr/utils";
 
+import type {
+  TimelineEventDto,
+  TimelineSessionDto,
+} from "~/session/hooks/queries";
 import { getSessionEvent } from "~/session/utils";
 
 function toTZ(date: Date, timezone?: string): Date {
   return timezone ? new TZDate(date, timezone) : date;
 }
 
-// comes from QUERIES.timelineEvents
-export type TimelineEventRow = {
+type LegacyTimelineEventRow = {
   title?: string | null;
   started_at?: string | null;
   ended_at?: string | null;
   calendar_id?: string | null;
   tracking_id_event?: string | null;
-  has_recurrence_rules: boolean;
+  has_recurrence_rules?: boolean;
   recurrence_series_id?: string | null;
+  is_all_day?: boolean;
 };
 
-// comes from QUERIES.timelineSessions
-export type TimelineSessionRow = {
+type LegacyTimelineSessionRow = {
   title?: string | null;
   created_at?: string | null;
   event_json?: string | null;
   folder_id?: string | null;
 };
 
+export type TimelineEventRow = TimelineEventDto | LegacyTimelineEventRow;
+export type TimelineSessionRow = TimelineSessionDto | LegacyTimelineSessionRow;
+
 export type TimelineEventsTable =
   | Record<string, TimelineEventRow>
   | null
@@ -67,6 +73,35 @@ export type TimelineIndicatorPlacement =
   | { type: "before"; index: number }
   | { type: "after" };
 
+function getEventStartedAt(row: TimelineEventRow): string | null | undefined {
+  return "startedAt" in row ? row.startedAt : row.started_at;
+}
+
+function getEventEndedAt(row: TimelineEventRow): string | null | undefined {
+  return "endedAt" in row ? row.endedAt : row.ended_at;
+}
+
+function getEventTrackingId(row: TimelineEventRow): string {
+  const value =
+    "trackingIdEvent" in row ? row.trackingIdEvent : row.tracking_id_event;
+  return value ?? "";
+}
+
+function getSessionCreatedAt(
+  row: TimelineSessionRow,
+): string | null | undefined {
+  return "createdAt" in row ? row.createdAt : row.created_at;
+}
+
+function getSessionEventFromRow(row: TimelineSessionRow) {
+  return "event" in row
+    ? row.event
+    : getSessionEvent({
+        event_json:
+          typeof row.event_json === "string" ? row.event_json : undefined,
+      });
+}
+
 export function getBucketInfo(
   date: Date,
   timezone?: string,
@@ -196,14 +231,16 @@ export function getItemTimeRange(item: TimelineItem): {
 } {
   if (item.type === "event") {
     return {
-      start: safeParseDate(item.data.started_at),
-      end: safeParseDate(item.data.ended_at),
+      start: safeParseDate(getEventStartedAt(item.data)),
+      end: safeParseDate(getEventEndedAt(item.data)),
     };
   }
 
-  const sessionEvent = getSessionEvent(item.data);
+  const sessionEvent = getSessionEventFromRow(item.data);
   return {
-    start: safeParseDate(sessionEvent?.started_at ?? item.data.created_at),
+    start: safeParseDate(
+      sessionEvent?.started_at ?? getSessionCreatedAt(item.data),
+    ),
     end: safeParseDate(sessionEvent?.ended_at),
   };
 }
@@ -298,7 +335,8 @@ export function filterTimelineTablesUpToTomorrow({
       ? Object.fromEntries(
           Object.entries(timelineEventsTable).filter(([, row]) =>
             isAtOrBeforeTomorrow(
-              safeParseDate(row.started_at) ?? safeParseDate(row.ended_at),
+              safeParseDate(getEventStartedAt(row)) ??
+                safeParseDate(getEventEndedAt(row)),
               timezone,
             ),
           ),
@@ -308,7 +346,10 @@ export function filterTimelineTablesUpToTomorrow({
       ? Object.fromEntries(
           Object.entries(timelineSessionsTable).filter(([, row]) =>
             isAtOrBeforeTomorrow(
-              safeParseDate(getSessionEvent(row)?.started_at ?? row.created_at),
+              safeParseDate(
+                getSessionEventFromRow(row)?.started_at ??
+                  getSessionCreatedAt(row),
+              ),
               timezone,
             ),
           ),
@@ -330,7 +371,9 @@ export function hasTimelineItemsAfterTomorrow({
     timelineSessionsTable &&
     Object.values(timelineSessionsTable).some((row) =>
       isAfterTomorrow(
-        safeParseDate(getSessionEvent(row)?.started_at ?? row.created_at),
+        safeParseDate(
+          getSessionEventFromRow(row)?.started_at ?? getSessionCreatedAt(row),
+        ),
         timezone,
       ),
     )
@@ -342,7 +385,8 @@ export function hasTimelineItemsAfterTomorrow({
     timelineEventsTable &&
     Object.values(timelineEventsTable).some((row) =>
       isAfterTomorrow(
-        safeParseDate(row.started_at) ?? safeParseDate(row.ended_at),
+        safeParseDate(getEventStartedAt(row)) ??
+          safeParseDate(getEventEndedAt(row)),
         timezone,
       ),
     )
@@ -353,12 +397,8 @@ export function hasTimelineItemsAfterTomorrow({
   return false;
 }
 
-function getEventTrackingId(row: TimelineEventRow): string {
-  return row.tracking_id_event ?? "";
-}
-
 function getSessionTrackingId(row: TimelineSessionRow): string {
-  const event = getSessionEvent(row);
+  const event = getSessionEventFromRow(row);
   if (!event) return "";
   return event.tracking_id;
 }
@@ -377,9 +417,8 @@ export function buildTimelineBuckets({
 
   if (timelineSessionsTable) {
     Object.entries(timelineSessionsTable).forEach(([sessionId, row]) => {
-      const sessionEvent = getSessionEvent(row);
       const startTime = safeParseDate(
-        sessionEvent?.started_at ?? row.created_at,
+        getSessionEventFromRow(row)?.started_at ?? getSessionCreatedAt(row),
       );
 
       if (!startTime) {
@@ -404,8 +443,8 @@ export function buildTimelineBuckets({
       if (trackingId && seenEventKeys.has(trackingId)) {
         return;
       }
-      const eventStartTime = safeParseDate(row.started_at);
-      const eventEndTime = safeParseDate(row.ended_at);
+      const eventStartTime = safeParseDate(getEventStartedAt(row));
+      const eventEndTime = safeParseDate(getEventEndedAt(row));
       const timeToCheck = eventEndTime || eventStartTime;
       if (!timeToCheck) {
         return;
diff --git a/apps/desktop/src/sidebar/toast/undo-delete-toast.tsx b/apps/desktop/src/sidebar/toast/undo-delete-toast.tsx
index 61bbf9ba6b..8b2bd91a30 100644
--- a/apps/desktop/src/sidebar/toast/undo-delete-toast.tsx
+++ b/apps/desktop/src/sidebar/toast/undo-delete-toast.tsx
@@ -5,8 +5,7 @@ import { createPortal } from "react-dom";
 
 import { cn } from "@hypr/utils";
 
-import { restoreSessionData } from "~/store/tinybase/store/deleteSession";
-import * as main from "~/store/tinybase/store/main";
+import { useRestoreDeletedSessions } from "~/session/hooks/runtime";
 import { useTabs } from "~/store/zustand/tabs";
 import { UNDO_TIMEOUT_MS, useUndoDelete } from "~/store/zustand/undo-delete";
 
@@ -63,7 +62,7 @@ function useToastGroups(): ToastGroup[] {
 }
 
 function useRestoreGroup() {
-  const store = main.UI.useStore(main.STORE_ID);
+  const restoreDeletedSessions = useRestoreDeletedSessions();
   const queryClient = useQueryClient();
   const pendingDeletions = useUndoDelete((state) => state.pendingDeletions);
   const clearDeletion = useUndoDelete((state) => state.clearDeletion);
@@ -72,35 +71,29 @@ function useRestoreGroup() {
 
   return useCallback(
     (group: ToastGroup) => {
-      if (!store) return;
-
-      for (const sessionId of group.sessionIds) {
-        const pending = pendingDeletions[sessionId];
-        if (!pending) continue;
-        restoreSessionData(store, pending.data);
-        void queryClient.invalidateQueries({
-          predicate: (query) =>
-            query.queryKey.length >= 2 &&
-            query.queryKey[0] === "audio" &&
-            query.queryKey[1] === sessionId,
-        });
-      }
-
-      if (group.sessionIds.length > 0) {
-        openCurrent({
-          type: "sessions",
-          id: group.sessionIds[0],
-        });
-      }
-
-      if (group.isBatch) {
-        clearBatch(group.key);
-      } else {
-        clearDeletion(group.sessionIds[0]);
-      }
+      restoreDeletedSessions({
+        sessionIds: group.sessionIds,
+        pendingDeletions,
+        clearDeletion,
+        clearBatch,
+        batchKey: group.isBatch ? group.key : undefined,
+        openSession: (sessionId) =>
+          openCurrent({
+            type: "sessions",
+            id: sessionId,
+          }),
+        invalidateAudioQueries: (sessionId) => {
+          void queryClient.invalidateQueries({
+            predicate: (query) =>
+              query.queryKey.length >= 2 &&
+              query.queryKey[0] === "audio" &&
+              query.queryKey[1] === sessionId,
+          });
+        },
+      });
     },
     [
-      store,
+      restoreDeletedSessions,
       pendingDeletions,
       openCurrent,
       clearDeletion,
diff --git a/apps/desktop/src/store/tinybase/hooks/index.test.tsx b/apps/desktop/src/store/tinybase/hooks/index.test.tsx
deleted file mode 100644
index 0bfbef39ea..0000000000
--- a/apps/desktop/src/store/tinybase/hooks/index.test.tsx
+++ /dev/null
@@ -1,111 +0,0 @@
-import { renderHook } from "@testing-library/react";
-import { describe, expect, it } from "vitest";
-
-import {
-  TinyBaseTestWrapper,
-  useHuman,
-  useOrganization,
-  useSession,
-  useSetSessionRawMd,
-  useSetSessionTitle,
-} from ".";
-
-describe("TinyBase hooks", () => {
-  describe("useSession", () => {
-    it("returns an object with session fields", () => {
-      const { result } = renderHook(() => useSession("test-session"), {
-        wrapper: ({ children }) => (
-          <TinyBaseTestWrapper>{children}</TinyBaseTestWrapper>
-        ),
-      });
-
-      expect(result.current).toHaveProperty("title");
-      expect(result.current).toHaveProperty("rawMd");
-      expect(result.current).toHaveProperty("createdAt");
-      expect(result.current).toHaveProperty("event");
-      expect(result.current).toHaveProperty("folderId");
-    });
-
-    it("returns undefined for non-existent session", () => {
-      const { result } = renderHook(() => useSession("non-existent"), {
-        wrapper: ({ children }) => (
-          <TinyBaseTestWrapper>{children}</TinyBaseTestWrapper>
-        ),
-      });
-
-      expect(result.current.title).toBeUndefined();
-      expect(result.current.rawMd).toBeUndefined();
-    });
-  });
-
-  describe("useSetSessionTitle", () => {
-    it("returns a function", () => {
-      const { result } = renderHook(() => useSetSessionTitle(), {
-        wrapper: ({ children }) => (
-          <TinyBaseTestWrapper>{children}</TinyBaseTestWrapper>
-        ),
-      });
-
-      expect(typeof result.current).toBe("function");
-    });
-  });
-
-  describe("useSetSessionRawMd", () => {
-    it("returns a function", () => {
-      const { result } = renderHook(() => useSetSessionRawMd(), {
-        wrapper: ({ children }) => (
-          <TinyBaseTestWrapper>{children}</TinyBaseTestWrapper>
-        ),
-      });
-
-      expect(typeof result.current).toBe("function");
-    });
-  });
-
-  describe("useHuman", () => {
-    it("returns an object with human fields", () => {
-      const { result } = renderHook(() => useHuman("test-human"), {
-        wrapper: ({ children }) => (
-          <TinyBaseTestWrapper>{children}</TinyBaseTestWrapper>
-        ),
-      });
-
-      expect(result.current).toHaveProperty("name");
-      expect(result.current).toHaveProperty("email");
-      expect(result.current).toHaveProperty("orgId");
-      expect(result.current).toHaveProperty("jobTitle");
-      expect(result.current).toHaveProperty("linkedinUsername");
-    });
-  });
-
-  describe("useOrganization", () => {
-    it("returns an object with organization fields", () => {
-      const { result } = renderHook(() => useOrganization("test-org"), {
-        wrapper: ({ children }) => (
-          <TinyBaseTestWrapper>{children}</TinyBaseTestWrapper>
-        ),
-      });
-
-      expect(result.current).toHaveProperty("name");
-    });
-  });
-
-  describe("TinyBaseTestWrapper", () => {
-    it("provides store context for hooks", () => {
-      const { result } = renderHook(
-        () => ({
-          session: useSession("session-1"),
-          human: useHuman("human-1"),
-        }),
-        {
-          wrapper: ({ children }) => (
-            <TinyBaseTestWrapper>{children}</TinyBaseTestWrapper>
-          ),
-        },
-      );
-
-      expect(result.current.session).toHaveProperty("title");
-      expect(result.current.human).toHaveProperty("name");
-    });
-  });
-});
diff --git a/apps/desktop/src/store/tinybase/hooks/index.tsx b/apps/desktop/src/store/tinybase/hooks/index.tsx
deleted file mode 100644
index 04a9429158..0000000000
--- a/apps/desktop/src/store/tinybase/hooks/index.tsx
+++ /dev/null
@@ -1,431 +0,0 @@
-import { type ReactNode, useCallback, useMemo } from "react";
-
-import type {
-  EnhancedNoteStorage,
-  HumanStorage,
-  IgnoredEvent,
-  IgnoredRecurringSeries,
-  OrganizationStorage,
-  SessionEvent,
-  SessionStorage,
-} from "@hypr/store";
-
-import { getSessionEvent } from "~/session/utils";
-import * as main from "~/store/tinybase/store/main";
-
-export function useSession(sessionId: string) {
-  const title = main.UI.useCell("sessions", sessionId, "title", main.STORE_ID);
-  const rawMd = main.UI.useCell("sessions", sessionId, "raw_md", main.STORE_ID);
-  const createdAt = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "created_at",
-    main.STORE_ID,
-  );
-  const eventJson = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "event_json",
-    main.STORE_ID,
-  );
-  const folderId = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "folder_id",
-    main.STORE_ID,
-  );
-
-  const event = useMemo(
-    () => getSessionEvent({ event_json: eventJson }),
-    [eventJson],
-  );
-
-  return useMemo(
-    () => ({ title, rawMd, createdAt, event, folderId }),
-    [title, rawMd, createdAt, event, folderId],
-  );
-}
-
-export function useSessionEvent(sessionId: string): SessionEvent | null {
-  const eventJson = main.UI.useCell(
-    "sessions",
-    sessionId,
-    "event_json",
-    main.STORE_ID,
-  );
-  return useMemo(() => getSessionEvent({ event_json: eventJson }), [eventJson]);
-}
-
-export function useSetSessionTitle() {
-  const store = main.UI.useStore(main.STORE_ID);
-
-  return useCallback(
-    (sessionId: string, title: string) => {
-      if (!store) return;
-      store.setPartialRow("sessions", sessionId, { title });
-    },
-    [store],
-  );
-}
-
-export function useSetSessionRawMd() {
-  const store = main.UI.useStore(main.STORE_ID);
-
-  return useCallback(
-    (sessionId: string, rawMd: string) => {
-      if (!store) return;
-      store.setPartialRow("sessions", sessionId, { raw_md: rawMd });
-    },
-    [store],
-  );
-}
-
-export function useHuman(humanId: string) {
-  const name = main.UI.useCell("humans", humanId, "name", main.STORE_ID);
-  const email = main.UI.useCell("humans", humanId, "email", main.STORE_ID);
-  const orgId = main.UI.useCell("humans", humanId, "org_id", main.STORE_ID);
-  const jobTitle = main.UI.useCell(
-    "humans",
-    humanId,
-    "job_title",
-    main.STORE_ID,
-  );
-  const linkedinUsername = main.UI.useCell(
-    "humans",
-    humanId,
-    "linkedin_username",
-    main.STORE_ID,
-  );
-
-  return useMemo(
-    () => ({ name, email, orgId, jobTitle, linkedinUsername }),
-    [name, email, orgId, jobTitle, linkedinUsername],
-  );
-}
-
-export function useOrganization(orgId: string) {
-  const name = main.UI.useCell("organizations", orgId, "name", main.STORE_ID);
-
-  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 {
-    return JSON.parse(raw) as IgnoredEvent[];
-  } catch {
-    return [];
-  }
-}
-
-function parseIgnoredSeries(raw: string | undefined): IgnoredRecurringSeries[] {
-  if (!raw) return [];
-  try {
-    return JSON.parse(raw) as IgnoredRecurringSeries[];
-  } catch {
-    return [];
-  }
-}
-
-export function useIgnoredEvents() {
-  const store = main.UI.useStore(main.STORE_ID);
-
-  const ignoredEventsRaw = main.UI.useValue("ignored_events", main.STORE_ID) as
-    | string
-    | undefined;
-  const ignoredSeriesRaw = main.UI.useValue(
-    "ignored_recurring_series",
-    main.STORE_ID,
-  ) as string | undefined;
-
-  const ignoredIds = useMemo(() => {
-    const list = parseIgnoredEvents(ignoredEventsRaw);
-    return new Set(list.map((e) => e.tracking_id));
-  }, [ignoredEventsRaw]);
-
-  const ignoredSeriesIds = useMemo(() => {
-    const list = parseIgnoredSeries(ignoredSeriesRaw);
-    return new Set(list.map((e) => e.id));
-  }, [ignoredSeriesRaw]);
-
-  const isIgnored = useCallback(
-    (
-      trackingId: string | null | undefined,
-      recurrenceSeriesId: string | null | undefined,
-    ) => {
-      if (!trackingId) return false;
-      if (ignoredIds.has(trackingId)) return true;
-      if (recurrenceSeriesId && ignoredSeriesIds.has(recurrenceSeriesId))
-        return true;
-      return false;
-    },
-    [ignoredIds, ignoredSeriesIds],
-  );
-
-  const ignoreEvent = useCallback(
-    (trackingId: string) => {
-      if (!store) return;
-      const list = parseIgnoredEvents(
-        store.getValue("ignored_events") as string | undefined,
-      );
-      const now = new Date().toISOString();
-      list.push({
-        tracking_id: trackingId,
-        last_seen: now,
-      });
-      store.setValue("ignored_events", JSON.stringify(list));
-    },
-    [store],
-  );
-
-  const unignoreEvent = useCallback(
-    (trackingId: string) => {
-      if (!store) return;
-      const list = parseIgnoredEvents(
-        store.getValue("ignored_events") as string | undefined,
-      );
-      const filtered = list.filter((e) => e.tracking_id !== trackingId);
-      store.setValue("ignored_events", JSON.stringify(filtered));
-    },
-    [store],
-  );
-
-  const ignoreSeries = useCallback(
-    (seriesId: string) => {
-      if (!store) return;
-      const list = parseIgnoredSeries(
-        store.getValue("ignored_recurring_series") as string | undefined,
-      );
-      if (!list.some((e) => e.id === seriesId)) {
-        list.push({ id: seriesId, last_seen: new Date().toISOString() });
-        store.setValue("ignored_recurring_series", JSON.stringify(list));
-      }
-    },
-    [store],
-  );
-
-  const unignoreSeries = useCallback(
-    (seriesId: string) => {
-      if (!store) return;
-      const list = parseIgnoredSeries(
-        store.getValue("ignored_recurring_series") as string | undefined,
-      );
-      store.setValue(
-        "ignored_recurring_series",
-        JSON.stringify(list.filter((e) => e.id !== seriesId)),
-      );
-    },
-    [store],
-  );
-
-  return {
-    isIgnored,
-    ignoreEvent,
-    unignoreEvent,
-    ignoreSeries,
-    unignoreSeries,
-  };
-}
-
-interface TinyBaseTestWrapperProps {
-  children: ReactNode;
-  initialData?: {
-    sessions?: Record<string, Partial<SessionStorage>>;
-    humans?: Record<string, Partial<HumanStorage>>;
-    organizations?: Record<string, Partial<OrganizationStorage>>;
-    enhanced_notes?: Record<string, Partial<EnhancedNoteStorage>>;
-  };
-  initialValues?: {
-    user_id?: string;
-  };
-}
-
-export function TinyBaseTestWrapper({
-  children,
-  initialData,
-  initialValues,
-}: TinyBaseTestWrapperProps) {
-  const {
-    useCreateMergeableStore,
-    useProvideStore,
-    useProvideIndexes,
-    useProvideRelationships,
-    useProvideQueries,
-    useCreateIndexes,
-    useCreateRelationships,
-    useCreateQueries,
-    createMergeableStore,
-    createIndexes,
-    createQueries,
-    createRelationships,
-    SCHEMA,
-  } = main.testUtils;
-
-  const store = useCreateMergeableStore(() => {
-    const s = createMergeableStore()
-      .setTablesSchema(SCHEMA.table)
-      .setValuesSchema(SCHEMA.value);
-
-    if (initialValues?.user_id) {
-      s.setValue("user_id", initialValues.user_id);
-    }
-
-    if (initialData?.sessions) {
-      Object.entries(initialData.sessions).forEach(([id, data]) => {
-        s.setRow("sessions", id, data as Record<string, unknown>);
-      });
-    }
-    if (initialData?.humans) {
-      Object.entries(initialData.humans).forEach(([id, data]) => {
-        s.setRow("humans", id, data as Record<string, unknown>);
-      });
-    }
-    if (initialData?.organizations) {
-      Object.entries(initialData.organizations).forEach(([id, data]) => {
-        s.setRow("organizations", id, data as Record<string, unknown>);
-      });
-    }
-    if (initialData?.enhanced_notes) {
-      Object.entries(initialData.enhanced_notes).forEach(([id, data]) => {
-        s.setRow("enhanced_notes", id, data as Record<string, unknown>);
-      });
-    }
-
-    return s;
-  });
-
-  const indexes = useCreateIndexes(store, (store) =>
-    createIndexes(store)
-      .setIndexDefinition(
-        main.INDEXES.sessionParticipantsBySession,
-        "mapping_session_participant",
-        "session_id",
-      )
-      .setIndexDefinition(
-        main.INDEXES.sessionsByFolder,
-        "sessions",
-        "folder_id",
-        "created_at",
-      )
-      .setIndexDefinition(
-        main.INDEXES.transcriptBySession,
-        "transcripts",
-        "session_id",
-        "created_at",
-      )
-      .setIndexDefinition(
-        main.INDEXES.enhancedNotesBySession,
-        "enhanced_notes",
-        "session_id",
-        "position",
-      ),
-  );
-
-  const relationships = useCreateRelationships(store, (store) =>
-    createRelationships(store).setRelationshipDefinition(
-      main.RELATIONSHIPS.enhancedNoteToSession,
-      "enhanced_notes",
-      "sessions",
-      "session_id",
-    ),
-  );
-
-  const queries = useCreateQueries(store, (store) =>
-    createQueries(store)
-      .setQueryDefinition(
-        main.QUERIES.visibleHumans,
-        "humans",
-        ({ select }) => {
-          select("name");
-          select("email");
-          select("org_id");
-          select("job_title");
-          select("linkedin_username");
-        },
-      )
-      .setQueryDefinition(
-        main.QUERIES.visibleOrganizations,
-        "organizations",
-        ({ select }) => {
-          select("name");
-        },
-      ),
-  );
-
-  useProvideStore(main.STORE_ID, store);
-  useProvideIndexes(main.STORE_ID, indexes!);
-  useProvideRelationships(main.STORE_ID, relationships!);
-  useProvideQueries(main.STORE_ID, queries!);
-
-  return <>{children}</>;
-}
diff --git a/apps/desktop/src/store/zustand/tabs/schema.ts b/apps/desktop/src/store/zustand/tabs/schema.ts
index 5d60b535ac..7f2876e972 100644
--- a/apps/desktop/src/store/zustand/tabs/schema.ts
+++ b/apps/desktop/src/store/zustand/tabs/schema.ts
@@ -37,6 +37,7 @@ export type SettingsTab =
   | "lab"
   | "agent"
   | "developer"
+  | "dictation"
   | "transcription"
   | "intelligence"
   | "memory"
@@ -53,6 +54,7 @@ export const normalizeSettingsTab = (
     case "lab":
     case "agent":
     case "developer":
+    case "dictation":
     case "transcription":
     case "intelligence":
     case "memory":
diff --git a/apps/desktop/src/stt/contexts.test.tsx b/apps/desktop/src/stt/contexts.test.tsx
index 5395ee3c8a..ae78cd74bc 100644
--- a/apps/desktop/src/stt/contexts.test.tsx
+++ b/apps/desktop/src/stt/contexts.test.tsx
@@ -5,11 +5,13 @@ import { ListenerProvider } from "./contexts";
 
 import { createListenerStore } from "~/store/zustand/listener";
 
-const { listenMock, showNotificationMock, useStoreMock } = vi.hoisted(() => ({
-  listenMock: vi.fn(),
-  showNotificationMock: vi.fn(),
-  useStoreMock: vi.fn(() => null),
-}));
+const { listenMock, showNotificationMock, useStoreMock, useTableMock } =
+  vi.hoisted(() => ({
+    listenMock: vi.fn(),
+    showNotificationMock: vi.fn(),
+    useStoreMock: vi.fn(() => null),
+    useTableMock: vi.fn(() => ({})),
+  }));
 
 vi.mock("@hypr/plugin-detect", () => ({
   events: {
@@ -29,6 +31,7 @@ vi.mock("~/store/tinybase/store/main", () => ({
   STORE_ID: "test-store",
   UI: {
     useStore: useStoreMock,
+    useTable: useTableMock,
   },
 }));
 
@@ -37,7 +40,9 @@ describe("ListenerProvider detect events", () => {
     listenMock.mockReset();
     showNotificationMock.mockReset();
     useStoreMock.mockReset();
+    useTableMock.mockReset();
     useStoreMock.mockReturnValue(null);
+    useTableMock.mockReturnValue({});
     listenMock.mockResolvedValue(() => {});
   });
 
diff --git a/apps/desktop/src/stt/contexts.tsx b/apps/desktop/src/stt/contexts.tsx
index ad3d084c16..e460fe76e0 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 { useNearbyEventsForMicPrompt } from "~/session/hooks/runtime";
 import {
   createListenerStore,
   type ListenerStore,
@@ -56,43 +56,10 @@ export const useListener = <T,>(
   return useStore(store, useShallow(selector));
 };
 
-function getNearbyEvents(
-  tinybaseStore: NonNullable<ReturnType<typeof main.UI.useStore>>,
-): { id: string; title: string }[] {
-  const now = Date.now();
-  const windowMs = 15 * 60 * 1000;
-  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;
-
-    const startTime = new Date(String(event.started_at)).getTime();
-    if (isNaN(startTime)) return;
-
-    if (Math.abs(startTime - now) <= windowMs) {
-      results.push({
-        id: eventId,
-        title: String(event.title || "Untitled Event"),
-        startedAt: startTime,
-      });
-    }
-  });
-
-  results.sort((a, b) => a.startedAt - b.startedAt);
-  return results.map(({ id, title }) => ({ id, title }));
-}
-
 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]);
+  const getNearbyEvents = useNearbyEventsForMicPrompt();
 
   useEffect(() => {
     let unlisten: (() => void) | undefined;
@@ -105,10 +72,7 @@ const useHandleDetectEvents = (store: ListenerStore) => {
             return;
           }
 
-          const currentTinybaseStore = tinybaseStoreRef.current;
-          const nearbyEvents = currentTinybaseStore
-            ? getNearbyEvents(currentTinybaseStore)
-            : [];
+          const nearbyEvents = getNearbyEvents();
           const ignorableAppIds = getIgnorableAppIds(payload.apps);
 
           const options =
@@ -168,5 +132,5 @@ const useHandleDetectEvents = (store: ListenerStore) => {
       cancelled = true;
       unlisten?.();
     };
-  }, [stop, setMuted]);
+  }, [getNearbyEvents, stop, setMuted]);
 };
diff --git a/apps/desktop/src/stt/session-storage.ts b/apps/desktop/src/stt/session-storage.ts
new file mode 100644
index 0000000000..3cd5b0bfdf
--- /dev/null
+++ b/apps/desktop/src/stt/session-storage.ts
@@ -0,0 +1,297 @@
+import { useCallback } from "react";
+
+import { commands as fsSyncCommands } from "@hypr/plugin-fs-sync";
+import type { TranscriptStorage } from "@hypr/store";
+
+import { estimateUploadedAudioSessionCreatedAt } from "./audio-note-date";
+
+import { useCurrentUserId } from "~/session/hooks/globals";
+import { useMainStoreInternal } from "~/session/hooks/internal";
+import { useSessionParticipantHumanIds } from "~/session/hooks/participants";
+import {
+  useSessionCellOptional,
+  useSessionEvent,
+} from "~/session/hooks/sessions";
+import { useTranscriptIdsForSession } from "~/session/hooks/transcripts";
+import { id } from "~/shared/utils";
+import type {
+  LiveTranscriptPersistCallback,
+  BatchPersistCallback,
+} from "~/store/zustand/listener/transcript";
+import type { SpeakerHintWithId, WordWithId } from "~/stt/types";
+import { applyLiveTranscriptDelta } from "~/stt/utils";
+import {
+  parseTranscriptHints,
+  parseTranscriptWords,
+  updateTranscriptHints,
+  updateTranscriptWords,
+} from "~/stt/utils";
+
+export function useLiveTranscriptPersistence(sessionId: string): {
+  participantHumanIds: string[];
+  hasCalendarEvent: boolean;
+  persistDelta: (args: {
+    currentTranscriptId: string | null;
+    startedAt: number;
+    createdAt: string;
+    delta: Parameters<LiveTranscriptPersistCallback>[0];
+  }) => string | null;
+  rollbackTranscript: (transcriptId: string | null) => void;
+} {
+  const store = useMainStoreInternal();
+  const userId = useCurrentUserId();
+  const memoMd = useSessionCellOptional(sessionId, "raw_md");
+  const participantHumanIds = useSessionParticipantHumanIds(sessionId);
+  const hasCalendarEvent = useSessionEvent(sessionId) !== null;
+
+  const persistDelta = useCallback(
+    ({
+      currentTranscriptId,
+      startedAt,
+      createdAt,
+      delta,
+    }: {
+      currentTranscriptId: string | null;
+      startedAt: number;
+      createdAt: string;
+      delta: Parameters<LiveTranscriptPersistCallback>[0];
+    }) => {
+      if (!store) return currentTranscriptId;
+      if (delta.new_words.length === 0 && delta.replaced_ids.length === 0) {
+        return currentTranscriptId;
+      }
+
+      let transcriptId = currentTranscriptId;
+      if (!transcriptId) {
+        transcriptId = id();
+        const transcriptRow = {
+          session_id: sessionId,
+          user_id: userId ?? "",
+          created_at: createdAt,
+          started_at: startedAt,
+          words: "[]",
+          speaker_hints: "[]",
+          memo_md: typeof memoMd === "string" ? memoMd : "",
+        } satisfies TranscriptStorage;
+
+        store.setRow("transcripts", transcriptId, transcriptRow);
+      }
+
+      store.transaction(() => {
+        applyLiveTranscriptDelta(store, transcriptId!, delta);
+      });
+
+      return transcriptId;
+    },
+    [memoMd, sessionId, store, userId],
+  );
+
+  const rollbackTranscript = useCallback(
+    (transcriptId: string | null) => {
+      if (!store || !transcriptId) return;
+      store.delRow("transcripts", transcriptId);
+    },
+    [store],
+  );
+
+  return {
+    participantHumanIds,
+    hasCalendarEvent,
+    persistDelta,
+    rollbackTranscript,
+  };
+}
+
+export function useBatchTranscriptPersistence(sessionId: string): {
+  buildPersist: (
+    provider: string,
+    handlePersist?: BatchPersistCallback,
+  ) => BatchPersistCallback;
+} {
+  const store = useMainStoreInternal();
+  const userId = useCurrentUserId();
+  const memoMd = useSessionCellOptional(sessionId, "raw_md");
+  const transcriptIdsForSession = useTranscriptIdsForSession(sessionId);
+
+  const buildPersist = useCallback(
+    (provider: string, handlePersist?: BatchPersistCallback) => {
+      if (handlePersist) {
+        return handlePersist;
+      }
+
+      let transcriptId: string | null = null;
+      const createdAt = new Date().toISOString();
+
+      return (
+        words: Parameters<BatchPersistCallback>[0],
+        hints: Parameters<BatchPersistCallback>[1],
+      ) => {
+        if (!store || words.length === 0) {
+          return;
+        }
+
+        if (!transcriptId) {
+          transcriptId = id();
+          const currentTranscriptId = transcriptId;
+
+          const transcriptRow = {
+            session_id: sessionId,
+            user_id: userId ?? "",
+            created_at: createdAt,
+            started_at: Date.now(),
+            words: "[]",
+            speaker_hints: "[]",
+            memo_md: typeof memoMd === "string" ? memoMd : "",
+          } satisfies TranscriptStorage;
+
+          store.transaction(() => {
+            for (const existingTranscriptId of transcriptIdsForSession ?? []) {
+              store.delRow("transcripts", existingTranscriptId);
+            }
+
+            store.setRow("transcripts", currentTranscriptId, transcriptRow);
+          });
+        }
+
+        const currentTranscriptId = transcriptId;
+        if (!currentTranscriptId) {
+          return;
+        }
+
+        const existingWords = parseTranscriptWords(store, currentTranscriptId);
+        const existingHints = parseTranscriptHints(store, currentTranscriptId);
+
+        const newWords: WordWithId[] = [];
+        const newWordIds: string[] = [];
+
+        words.forEach((word) => {
+          const wordId = id();
+
+          newWords.push({
+            id: wordId,
+            text: word.text,
+            start_ms: word.start_ms,
+            end_ms: word.end_ms,
+            channel: word.channel,
+          });
+
+          newWordIds.push(wordId);
+        });
+
+        const newHints: SpeakerHintWithId[] = [];
+
+        hints.forEach((hint) => {
+          if (hint.data.type !== "provider_speaker_index") {
+            return;
+          }
+
+          const wordId = newWordIds[hint.wordIndex];
+          const word = words[hint.wordIndex];
+
+          if (!wordId || !word) {
+            return;
+          }
+
+          newHints.push({
+            id: id(),
+            word_id: wordId,
+            type: "provider_speaker_index",
+            value: JSON.stringify({
+              provider: hint.data.provider ?? provider,
+              channel: hint.data.channel ?? word.channel,
+              speaker_index: hint.data.speaker_index,
+            }),
+          });
+        });
+
+        updateTranscriptWords(store, currentTranscriptId, [
+          ...existingWords,
+          ...newWords,
+        ]);
+        updateTranscriptHints(store, currentTranscriptId, [
+          ...existingHints,
+          ...newHints,
+        ]);
+      };
+    },
+    [memoMd, sessionId, store, transcriptIdsForSession, userId],
+  );
+
+  return { buildPersist };
+}
+
+export function useUploadTranscriptImport(sessionId: string): {
+  applyEstimatedAudioNoteDate: (filePath: string) => Promise<void>;
+  importSubtitleTokens: (
+    tokens: Array<{ text: string; start_time: number; end_time: number }>,
+  ) => void;
+} {
+  const store = useMainStoreInternal();
+  const userId = useCurrentUserId();
+  const rawMd = useSessionCellOptional(sessionId, "raw_md");
+  const event = useSessionEvent(sessionId);
+
+  const applyEstimatedAudioNoteDate = useCallback(
+    async (filePath: string) => {
+      try {
+        if (!store || event) {
+          return;
+        }
+
+        const result = await fsSyncCommands.audioSourceMetadata(filePath);
+        if (result.status === "error") {
+          return;
+        }
+
+        const estimatedCreatedAt = estimateUploadedAudioSessionCreatedAt(
+          result.data,
+        );
+        if (!estimatedCreatedAt) {
+          return;
+        }
+
+        store.setCell("sessions", sessionId, "created_at", estimatedCreatedAt);
+      } catch (error) {
+        console.error("[upload] audio metadata inspection failed:", error);
+      }
+    },
+    [event, sessionId, store],
+  );
+
+  const importSubtitleTokens = useCallback(
+    (tokens: Array<{ text: string; start_time: number; end_time: number }>) => {
+      if (!store || tokens.length === 0) {
+        return;
+      }
+
+      const transcriptId = crypto.randomUUID();
+      const createdAt = new Date().toISOString();
+
+      const words = tokens.map((token) => ({
+        id: crypto.randomUUID(),
+        transcript_id: transcriptId,
+        text: token.text,
+        start_ms: token.start_time,
+        end_ms: token.end_time,
+        channel: 2,
+        user_id: userId ?? "",
+        created_at: new Date().toISOString(),
+      }));
+
+      const transcriptRow = {
+        session_id: sessionId,
+        user_id: userId ?? "",
+        created_at: createdAt,
+        started_at: Date.now(),
+        words: JSON.stringify(words),
+        speaker_hints: "[]",
+        memo_md: typeof rawMd === "string" ? rawMd : "",
+      } satisfies TranscriptStorage;
+
+      store.setRow("transcripts", transcriptId, transcriptRow);
+    },
+    [rawMd, sessionId, store, userId],
+  );
+
+  return { applyEstimatedAudioNoteDate, importSubtitleTokens };
+}
diff --git a/apps/desktop/src/stt/useKeywords.ts b/apps/desktop/src/stt/useKeywords.ts
index 4571319608..d8efd9019d 100644
--- a/apps/desktop/src/stt/useKeywords.ts
+++ b/apps/desktop/src/stt/useKeywords.ts
@@ -10,16 +10,15 @@ import retextStringify from "retext-stringify";
 import { unified } from "unified";
 import type { VFile } from "vfile";
 
-import * as main from "~/store/tinybase/store/main";
+import { useSessionCell } from "~/session/hooks/sessions";
 
 export function useKeywords(sessionId: string) {
-  const rawMd = main.UI.useCell("sessions", sessionId, "raw_md", main.STORE_ID);
+  const rawMd = useSessionCell(sessionId, "raw_md");
 
   return useMemo(() => {
-    const { keywords, keyphrases } =
-      rawMd && typeof rawMd === "string"
-        ? extractKeywordsFromMarkdown(rawMd)
-        : { keywords: [], keyphrases: [] };
+    const { keywords, keyphrases } = rawMd
+      ? extractKeywordsFromMarkdown(rawMd)
+      : { keywords: [], keyphrases: [] };
 
     return combineKeywords([...keywords, ...keyphrases]);
   }, [rawMd]);
diff --git a/apps/desktop/src/stt/useRunBatch.ts b/apps/desktop/src/stt/useRunBatch.ts
index f9f8c85f71..dc3e324c6a 100644
--- a/apps/desktop/src/stt/useRunBatch.ts
+++ b/apps/desktop/src/stt/useRunBatch.ts
@@ -1,23 +1,14 @@
 import { useCallback } from "react";
 
 import type { TranscriptionParams } from "@hypr/plugin-transcription";
-import type { TranscriptStorage } from "@hypr/store";
 
 import { useListener } from "./contexts";
+import { useBatchTranscriptPersistence } from "./session-storage";
 import { useKeywords } from "./useKeywords";
 import { useSTTConnection } from "./useSTTConnection";
 
 import { useConfigValue } from "~/shared/config";
-import { id } from "~/shared/utils";
-import * as main from "~/store/tinybase/store/main";
 import type { BatchPersistCallback } from "~/store/zustand/listener/transcript";
-import type { SpeakerHintWithId, WordWithId } from "~/stt/types";
-import {
-  parseTranscriptHints,
-  parseTranscriptWords,
-  updateTranscriptHints,
-  updateTranscriptWords,
-} from "~/stt/utils";
 
 type RunOptions = {
   handlePersist?: BatchPersistCallback;
@@ -80,9 +71,7 @@ export function isStoppedTranscriptionError(error: unknown) {
 }
 
 export const useRunBatch = (sessionId: string) => {
-  const store = main.UI.useStore(main.STORE_ID);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
-  const { user_id } = main.UI.useValues(main.STORE_ID);
+  const { buildPersist } = useBatchTranscriptPersistence(sessionId);
 
   const startTranscription = useListener((state) => state.startTranscription);
   const { conn } = useSTTConnection();
@@ -91,7 +80,7 @@ export const useRunBatch = (sessionId: string) => {
 
   return useCallback(
     async (filePath: string, options?: RunOptions) => {
-      if (!store || !conn || !startTranscription) {
+      if (!conn || !startTranscription) {
         throw new Error(
           "STT connection is not available. Please configure your speech-to-text provider.",
         );
@@ -108,115 +97,10 @@ export const useRunBatch = (sessionId: string) => {
         );
       }
 
-      const createdAt = new Date().toISOString();
-      const memoMd = store.getCell("sessions", sessionId, "raw_md");
-      let transcriptId: string | null = null;
-
       const handlePersist: BatchPersistCallback | undefined =
         options?.handlePersist;
 
-      const persist =
-        handlePersist ??
-        ((words, hints) => {
-          if (words.length === 0) {
-            return;
-          }
-
-          if (!transcriptId) {
-            transcriptId = id();
-            const currentTranscriptId = transcriptId;
-
-            const transcriptRow = {
-              session_id: sessionId,
-              user_id: user_id ?? "",
-              created_at: createdAt,
-              started_at: Date.now(),
-              words: "[]",
-              speaker_hints: "[]",
-              memo_md: typeof memoMd === "string" ? memoMd : "",
-            } satisfies TranscriptStorage;
-
-            store.transaction(() => {
-              const transcriptIds =
-                indexes?.getSliceRowIds(
-                  main.INDEXES.transcriptBySession,
-                  sessionId,
-                ) ?? [];
-
-              for (const existingTranscriptId of transcriptIds) {
-                store.delRow("transcripts", existingTranscriptId);
-              }
-
-              store.setRow("transcripts", currentTranscriptId, transcriptRow);
-            });
-          }
-
-          const currentTranscriptId = transcriptId;
-          if (!currentTranscriptId) {
-            return;
-          }
-
-          const existingWords = parseTranscriptWords(
-            store,
-            currentTranscriptId,
-          );
-          const existingHints = parseTranscriptHints(
-            store,
-            currentTranscriptId,
-          );
-
-          const newWords: WordWithId[] = [];
-          const newWordIds: string[] = [];
-
-          words.forEach((word) => {
-            const wordId = id();
-
-            newWords.push({
-              id: wordId,
-              text: word.text,
-              start_ms: word.start_ms,
-              end_ms: word.end_ms,
-              channel: word.channel,
-            });
-
-            newWordIds.push(wordId);
-          });
-
-          const newHints: SpeakerHintWithId[] = [];
-
-          hints.forEach((hint) => {
-            if (hint.data.type !== "provider_speaker_index") {
-              return;
-            }
-
-            const wordId = newWordIds[hint.wordIndex];
-            const word = words[hint.wordIndex];
-
-            if (!wordId || !word) {
-              return;
-            }
-
-            newHints.push({
-              id: id(),
-              word_id: wordId,
-              type: "provider_speaker_index",
-              value: JSON.stringify({
-                provider: hint.data.provider ?? conn.provider,
-                channel: hint.data.channel ?? word.channel,
-                speaker_index: hint.data.speaker_index,
-              }),
-            });
-          });
-
-          updateTranscriptWords(store, currentTranscriptId, [
-            ...existingWords,
-            ...newWords,
-          ]);
-          updateTranscriptHints(store, currentTranscriptId, [
-            ...existingHints,
-            ...newHints,
-          ]);
-        });
+      const persist = buildPersist(conn.provider, handlePersist);
 
       const params: TranscriptionParams = {
         session_id: sessionId,
@@ -234,15 +118,6 @@ export const useRunBatch = (sessionId: string) => {
 
       await startTranscription(params, { handlePersist: persist });
     },
-    [
-      conn,
-      indexes,
-      keywords,
-      languages,
-      startTranscription,
-      sessionId,
-      store,
-      user_id,
-    ],
+    [conn, buildPersist, keywords, languages, startTranscription, sessionId],
   );
 };
diff --git a/apps/desktop/src/stt/useStartListening.test.ts b/apps/desktop/src/stt/useStartListening.test.ts
index 44f8a3d9c0..ce382aa529 100644
--- a/apps/desktop/src/stt/useStartListening.test.ts
+++ b/apps/desktop/src/stt/useStartListening.test.ts
@@ -9,6 +9,10 @@ const {
   startMock,
   runBatchMock,
   useListenerMock,
+  useCellMock,
+  useSliceRowIdsMock,
+  useTableMock,
+  useResultTableMock,
   useValuesMock,
   useStoreMock,
   useIndexesMock,
@@ -18,6 +22,10 @@ const {
   startMock: vi.fn(),
   runBatchMock: vi.fn(),
   useListenerMock: vi.fn(),
+  useCellMock: vi.fn(() => ""),
+  useSliceRowIdsMock: vi.fn(() => []),
+  useTableMock: vi.fn(() => ({})),
+  useResultTableMock: vi.fn(() => ({})),
   useValuesMock: vi.fn(),
   useStoreMock: vi.fn(),
   useIndexesMock: vi.fn(),
@@ -61,6 +69,7 @@ vi.mock("~/services/enhancer", () => ({
 }));
 
 vi.mock("~/session/utils", () => ({
+  getSessionEvent: vi.fn(() => null),
   getSessionEventById: vi.fn(() => null),
 }));
 
@@ -76,9 +85,24 @@ vi.mock("~/store/tinybase/store/main", () => ({
   STORE_ID: "main",
   INDEXES: {
     transcriptBySession: "transcriptBySession",
+    sessionParticipantsBySession: "sessionParticipantsBySession",
+  },
+  QUERIES: {
+    sessionParticipantsWithDetails: "sessionParticipantsWithDetails",
   },
   UI: {
     useValues: useValuesMock,
+    useCell: useCellMock,
+    useSliceRowIds: useSliceRowIdsMock,
+    useTable: useTableMock,
+    useResultTable: useResultTableMock,
+    useValue: (key: string) => {
+      if (key === "user_id") {
+        const values = useValuesMock();
+        return values?.user_id;
+      }
+      return undefined;
+    },
     useStore: useStoreMock,
     useIndexes: useIndexesMock,
   },
@@ -143,6 +167,10 @@ describe("useStartListening", () => {
         start: startMock,
       }),
     );
+    useCellMock.mockReturnValue("");
+    useSliceRowIdsMock.mockReturnValue([]);
+    useTableMock.mockReturnValue({});
+    useResultTableMock.mockReturnValue({});
     useValuesMock.mockReturnValue({ user_id: "user-1" });
     useIndexesMock.mockReturnValue(null);
     useConfigValueMock.mockReturnValue([]);
diff --git a/apps/desktop/src/stt/useStartListening.ts b/apps/desktop/src/stt/useStartListening.ts
index 11b050663b..af3c555349 100644
--- a/apps/desktop/src/stt/useStartListening.ts
+++ b/apps/desktop/src/stt/useStartListening.ts
@@ -1,9 +1,9 @@
 import { useCallback, useRef } from "react";
 
 import { commands as analyticsCommands } from "@hypr/plugin-analytics";
-import type { TranscriptStorage } from "@hypr/store";
 
 import { useListener } from "./contexts";
+import { useLiveTranscriptPersistence } from "./session-storage";
 import { useKeywords } from "./useKeywords";
 import {
   canRunBatchTranscription,
@@ -13,15 +13,12 @@ import {
 import { useSTTConnection } from "./useSTTConnection";
 
 import { getEnhancerService } from "~/services/enhancer";
-import { getSessionEventById } from "~/session/utils";
+import { useCurrentUserId } from "~/session/hooks/globals";
 import { useConfigValue } from "~/shared/config";
-import { id } from "~/shared/utils";
-import * as main from "~/store/tinybase/store/main";
 import type {
   LiveTranscriptPersistCallback,
   OnStoppedCallback,
 } from "~/store/zustand/listener/transcript";
-import { applyLiveTranscriptDelta } from "~/stt/utils";
 
 export function getPostCaptureAction(
   details: {
@@ -42,9 +39,13 @@ export function getPostCaptureAction(
 }
 
 export function useStartListening(sessionId: string) {
-  const { user_id } = main.UI.useValues(main.STORE_ID);
-  const store = main.UI.useStore(main.STORE_ID);
-  const indexes = main.UI.useIndexes(main.STORE_ID);
+  const user_id = useCurrentUserId();
+  const {
+    participantHumanIds,
+    hasCalendarEvent,
+    persistDelta,
+    rollbackTranscript,
+  } = useLiveTranscriptPersistence(sessionId);
 
   const languages = useConfigValue("spoken_languages");
 
@@ -59,13 +60,8 @@ export function useStartListening(sessionId: string) {
   canRunBatchRef.current = canRunBatchTranscription(conn);
 
   const startListening = useCallback(async () => {
-    if (!store) {
-      return;
-    }
-
     let transcriptId: string | null = null;
     const startedAt = Date.now();
-    const memoMd = store.getCell("sessions", sessionId, "raw_md");
     const createdAt = new Date().toISOString();
 
     const onStopped: OnStoppedCallback = async (_sessionId, details) => {
@@ -101,47 +97,14 @@ export function useStartListening(sessionId: string) {
         return;
       }
 
-      if (!transcriptId) {
-        transcriptId = id();
-        const transcriptRow = {
-          session_id: sessionId,
-          user_id: user_id ?? "",
-          created_at: createdAt,
-          started_at: startedAt,
-          words: "[]",
-          speaker_hints: "[]",
-          memo_md: typeof memoMd === "string" ? memoMd : "",
-        } satisfies TranscriptStorage;
-
-        store.setRow("transcripts", transcriptId, transcriptRow);
-      }
-
-      store.transaction(() => {
-        applyLiveTranscriptDelta(store, transcriptId!, delta);
+      transcriptId = persistDelta({
+        currentTranscriptId: transcriptId,
+        startedAt,
+        createdAt,
+        delta,
       });
     };
 
-    const participantHumanIds: string[] = [];
-    store.forEachRow(
-      "mapping_session_participant",
-      (mappingId, _forEachCell) => {
-        const sid = store.getCell(
-          "mapping_session_participant",
-          mappingId,
-          "session_id",
-        );
-        if (sid !== sessionId) return;
-        const hid = store.getCell(
-          "mapping_session_participant",
-          mappingId,
-          "human_id",
-        );
-        if (typeof hid === "string" && hid) {
-          participantHumanIds.push(hid);
-        }
-      },
-    );
-
     const started = await start(
       {
         session_id: sessionId,
@@ -161,15 +124,13 @@ export function useStartListening(sessionId: string) {
     );
 
     if (!started) {
-      if (transcriptId) {
-        store.delRow("transcripts", transcriptId);
-      }
+      rollbackTranscript(transcriptId);
       return;
     }
 
     void analyticsCommands.event({
       event: "session_started",
-      has_calendar_event: !!getSessionEventById(store, sessionId),
+      has_calendar_event: hasCalendarEvent,
       ...(conn
         ? {
             stt_provider: conn.provider,
@@ -177,7 +138,18 @@ export function useStartListening(sessionId: string) {
           }
         : {}),
     });
-  }, [conn, store, indexes, sessionId, start, keywords, user_id, languages]);
+  }, [
+    conn,
+    sessionId,
+    start,
+    keywords,
+    user_id,
+    languages,
+    participantHumanIds,
+    persistDelta,
+    rollbackTranscript,
+    hasCalendarEvent,
+  ]);
 
   return startListening;
 }
diff --git a/apps/desktop/src/stt/useUploadFile.ts b/apps/desktop/src/stt/useUploadFile.ts
index 0abdf336ae..3b4e97cb27 100644
--- a/apps/desktop/src/stt/useUploadFile.ts
+++ b/apps/desktop/src/stt/useUploadFile.ts
@@ -10,16 +10,13 @@ import {
   events as fsSyncEvents,
 } from "@hypr/plugin-fs-sync";
 import { commands as listener2Commands } from "@hypr/plugin-transcription";
-import type { TranscriptStorage } from "@hypr/store";
 
-import { estimateUploadedAudioSessionCreatedAt } from "./audio-note-date";
 import { useListener } from "./contexts";
 import { fromResult } from "./fromResult";
-import { ChannelProfile } from "./segment";
+import { useUploadTranscriptImport } from "./session-storage";
 import { isStoppedTranscriptionError, useRunBatch } from "./useRunBatch";
 
 import { getEnhancerService } from "~/services/enhancer";
-import * as main from "~/store/tinybase/store/main";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
 
 const AUDIO_EXTENSIONS = ["wav", "mp3", "ogg", "mp4", "m4a", "flac"];
@@ -33,8 +30,8 @@ export function useUploadFile(sessionId: string) {
   const updateBatchProgress = useListener((state) => state.updateBatchProgress);
   const clearBatchSession = useListener((state) => state.clearBatchSession);
 
-  const store = main.UI.useStore(main.STORE_ID) as main.Store | undefined;
-  const { user_id } = main.UI.useValues(main.STORE_ID);
+  const { applyEstimatedAudioNoteDate, importSubtitleTokens } =
+    useUploadTranscriptImport(sessionId);
   const updateSessionTabState = useTabs((state) => state.updateSessionTabState);
   const sessionTab = useTabs((state) => {
     const found = state.tabs.find(
@@ -57,38 +54,6 @@ export function useUploadFile(sessionId: string) {
     }
   }, [sessionId, sessionTab, updateSessionTabState]);
 
-  const applyEstimatedAudioNoteDate = useCallback(
-    async (filePath: string) => {
-      try {
-        if (!store) {
-          return;
-        }
-
-        const eventJson = store.getCell("sessions", sessionId, "event_json");
-        if (typeof eventJson === "string" && eventJson.trim()) {
-          return;
-        }
-
-        const result = await fsSyncCommands.audioSourceMetadata(filePath);
-        if (result.status === "error") {
-          return;
-        }
-
-        const estimatedCreatedAt = estimateUploadedAudioSessionCreatedAt(
-          result.data,
-        );
-        if (!estimatedCreatedAt) {
-          return;
-        }
-
-        store.setCell("sessions", sessionId, "created_at", estimatedCreatedAt);
-      } catch (error) {
-        console.error("[upload] audio metadata inspection failed:", error);
-      }
-    },
-    [sessionId, store],
-  );
-
   const processFile = useCallback(
     (filePath: string, kind: "audio" | "transcript") => {
       const normalizedPath = filePath.toLowerCase();
@@ -105,36 +70,10 @@ export function useUploadFile(sessionId: string) {
           fromResult(listener2Commands.parseSubtitle(filePath)),
           Effect.tap((subtitle) =>
             Effect.sync(() => {
-              if (!store || subtitle.tokens.length === 0) {
+              if (subtitle.tokens.length === 0) {
                 return;
               }
-
-              const transcriptId = crypto.randomUUID();
-              const createdAt = new Date().toISOString();
-              const memoMd = store.getCell("sessions", sessionId, "raw_md");
-
-              const words = subtitle.tokens.map((token) => ({
-                id: crypto.randomUUID(),
-                transcript_id: transcriptId,
-                text: token.text,
-                start_ms: token.start_time,
-                end_ms: token.end_time,
-                channel: ChannelProfile.MixedCapture,
-                user_id: user_id ?? "",
-                created_at: new Date().toISOString(),
-              }));
-
-              const transcriptRow = {
-                session_id: sessionId,
-                user_id: user_id ?? "",
-                created_at: createdAt,
-                started_at: Date.now(),
-                words: JSON.stringify(words),
-                speaker_hints: "[]",
-                memo_md: typeof memoMd === "string" ? memoMd : "",
-              } satisfies TranscriptStorage;
-
-              store.setRow("transcripts", transcriptId, transcriptRow);
+              importSubtitleTokens(subtitle.tokens);
 
               void analyticsCommands.event({
                 event: "file_uploaded",
@@ -242,16 +181,15 @@ export function useUploadFile(sessionId: string) {
       clearBatchSession,
       handleBatchFailed,
       handleBatchStarted,
+      importSubtitleTokens,
       updateBatchProgress,
       queryClient,
       runBatch,
       sessionId,
       sessionTab,
-      store,
       triggerEnhance,
       applyEstimatedAudioNoteDate,
       updateSessionTabState,
-      user_id,
     ],
   );
 
diff --git a/apps/desktop/src/editor/task-storage.tsx b/apps/desktop/src/tasks/hooks.tsx
similarity index 98%
rename from apps/desktop/src/editor/task-storage.tsx
rename to apps/desktop/src/tasks/hooks.tsx
index dade6a5694..c10f614fc8 100644
--- a/apps/desktop/src/editor/task-storage.tsx
+++ b/apps/desktop/src/tasks/hooks.tsx
@@ -6,12 +6,17 @@ import {
   type ReactNode,
 } from "react";
 
-import type { JSONContent } from "./session";
-import { createTaskSourceKey, type TaskRecord, type TaskSource } from "./tasks";
-
+import type { JSONContent } from "~/editor/session";
+import {
+  createTaskSourceKey,
+  type TaskRecord,
+  type TaskSource,
+} from "~/editor/tasks";
 import { DEFAULT_USER_ID } from "~/shared/utils";
 import * as main from "~/store/tinybase/store/main";
 
+// Storage boundary for task records. Consumers use TaskStorage and task hooks
+// so backing storage can change without touching editor/session UIs.
 type Listener = () => void;
 type TaskStore = NonNullable<ReturnType<typeof main.UI.useStore>>;
 type TaskIndexes = NonNullable<ReturnType<typeof main.UI.useIndexes>>;
diff --git a/apps/desktop/src/templates/utils.ts b/apps/desktop/src/templates/utils.ts
index eb64c18bc1..f32d80c7f5 100644
--- a/apps/desktop/src/templates/utils.ts
+++ b/apps/desktop/src/templates/utils.ts
@@ -9,8 +9,9 @@ import {
   type UserTemplate,
 } from "./queries";
 
+import { useHumanCell } from "~/contacts/hooks";
+import { useCurrentUserId } from "~/session/hooks/globals";
 import { useWebResources } from "~/shared/ui/resource-list";
-import * as main from "~/store/tinybase/store/main";
 import { type Tab, useTabs } from "~/store/zustand/tabs";
 
 export function resolveTemplateTabSelection({
@@ -73,12 +74,10 @@ export function resolveTemplateTabSelection({
 }
 
 export function useTemplateCreatorName() {
-  const userId = main.UI.useValue("user_id", main.STORE_ID);
-  const name = main.UI.useCell("humans", userId ?? "", "name", main.STORE_ID);
+  const userId = useCurrentUserId();
+  const name = useHumanCell(userId ?? "", "name");
 
-  return typeof name === "string" && name.trim().length > 0
-    ? name.trim()
-    : "user";
+  return name.trim().length > 0 ? name.trim() : "user";
 }
 
 export function getTemplateCreatorLabel({
diff --git a/apps/desktop/vite.config.ts b/apps/desktop/vite.config.ts
index ad324532cf..a713b17bd3 100644
--- a/apps/desktop/vite.config.ts
+++ b/apps/desktop/vite.config.ts
@@ -1,7 +1,7 @@
 /// <reference types="vitest" />
 import { tanstackRouter } from "@tanstack/router-plugin/vite";
 import react from "@vitejs/plugin-react";
-import { defineConfig, type UserConfig } from "vite";
+import { defineConfig, type PluginOption, type UserConfig } from "vite";
 
 import { relayShim } from "@hypr/plugin-relay/vite";
 
@@ -10,43 +10,48 @@ import { changelog } from "./plugins/changelog";
 const host = process.env.TAURI_DEV_HOST;
 
 // https://vite.dev/config/
-export default defineConfig(() => ({
-  plugins: [
-    relayShim(),
-    changelog(),
-    tanstackRouter({ target: "react", autoCodeSplitting: false }),
-    react(),
-  ],
-  resolve: {
-    tsconfigPaths: true,
-    alias:
-      process.env.NODE_ENV === "development"
-        ? {
-            "@tauri-apps/plugin-updater": "/src/shared/mock-updater.ts",
-          }
-        : {},
-    dedupe: [
-      "@codemirror/state",
-      "@codemirror/view",
-      "@codemirror/autocomplete",
-      "@codemirror/language",
-      "@codemirror/lint",
-      "@codemirror/lang-jinja",
-      "codemirror-readonly-ranges",
-      "@uiw/react-codemirror",
-    ],
-  },
-  test: {
-    reporters: "default",
-    environment: "jsdom",
-    setupFiles: ["./src/test-setup.ts"],
-    onConsoleLog: (_, type) => {
-      return type === "stderr";
+export default defineConfig(() => {
+  const isTest = process.env.VITEST === "true";
+
+  return {
+    plugins: [
+      relayShim(),
+      changelog(),
+      !isTest && tanstackRouter({ target: "react", autoCodeSplitting: false }),
+      react(),
+    ].filter(Boolean) as PluginOption[],
+    resolve: {
+      tsconfigPaths: true,
+      alias:
+        process.env.NODE_ENV === "development"
+          ? {
+              "@tauri-apps/plugin-updater": "/src/shared/mock-updater.ts",
+            }
+          : {},
+      dedupe: [
+        "@codemirror/state",
+        "@codemirror/view",
+        "@codemirror/autocomplete",
+        "@codemirror/language",
+        "@codemirror/lint",
+        "@codemirror/lang-jinja",
+        "codemirror-readonly-ranges",
+        "@uiw/react-codemirror",
+      ],
     },
-    exclude: ["**/node_modules/**", "**/src-tauri/**"],
-  },
-  ...tauri,
-}));
+    test: {
+      reporters: "default",
+      environment: "jsdom",
+      maxWorkers: 1,
+      setupFiles: ["./src/test-setup.ts"],
+      onConsoleLog: (_, type) => {
+        return type === "stderr";
+      },
+      exclude: ["**/node_modules/**", "**/src-tauri/**"],
+    },
+    ...tauri,
+  };
+});
 
 // https://v2.tauri.app/start/frontend/vite/#update-vite-configuration
 const tauri: UserConfig = {
diff --git a/eslint-plugin-hypr.mjs b/eslint-plugin-hypr.mjs
index 8ecf7dfd95..bd5d6044c4 100644
--- a/eslint-plugin-hypr.mjs
+++ b/eslint-plugin-hypr.mjs
@@ -91,7 +91,12 @@ const BANNED_TINYBASE_EXACT_IMPORTS = new Set([
   "tinybase",
 ]);
 
-const BANNED_MAIN_STORE_IMPORTS = new Set(["~/store/tinybase/store/main"]);
+const BANNED_MAIN_STORE_IMPORTS = new Set([
+  "~/store/tinybase/store/main",
+  "~/store/tinybase/hooks",
+]);
+
+const BANNED_MAIN_STORE_IMPORT_PREFIXES = ["~/store/tinybase/hooks/"];
 
 const noRawTinybase = {
   meta: {
@@ -135,7 +140,13 @@ const noRawTinybase = {
           }
         }
 
-        if (BANNED_MAIN_STORE_IMPORTS.has(source)) {
+        const isBannedMainStore =
+          BANNED_MAIN_STORE_IMPORTS.has(source) ||
+          BANNED_MAIN_STORE_IMPORT_PREFIXES.some((prefix) =>
+            source.startsWith(prefix),
+          );
+
+        if (isBannedMainStore) {
           const hasRuntimeSpecifier = node.specifiers.some(
             (s) =>
               s.type === "ImportNamespaceSpecifier" ||