Skip to content

Voice-to-text dictation app with local (Nvidia Parakeet/Whisper) and cloud models (BYOK). Privacy-first and available cross-platform.

38.6 KB
Raw Blame
import { isManagedMeetingAudioUri } from '@/lib/transcriptAudio';
import { create } from 'zustand';
import * as Sentry from '@sentry/react-native';
import { notesRepository, spacesRepository } from '@/data';
import type { Note, Folder, NoteUpdate, Space } from '@/data';
import type { ConflictedNote, Segment, Speaker, SpeakerProfile } from '@/data/types';
import type { CalendarParticipant } from '@/data/calendarTypes';
import type { Diarizer } from '@/lib/diarization/diarizer';
import { useAuthStore } from '@/store/useAuthStore';
import { useProcessingModeStore } from '@/store/useProcessingModeStore';
import { useConfigStore } from '@/store/useConfigStore';
import { deletePrivateNoteCloudCopy, queuePrivateNoteDeletion } from '@/sync/privateNoteDeletion';
import { createSyncContext } from '@/sync/createSyncContext';
import { getPreferredTranscriptionLanguage } from '@/lib/transcriptionLanguage';
import type { TranscriptionStatus } from '@/types';
import type { RealtimeUtterance } from '@/services/transcription/realtimeEvents';
import { assertTransition } from '@/lib/diarization/transcriptionStatus';
import { formatTranscriptForExport } from '@/lib/diarization/transcriptDisplay';
import { buildMergeTargetPatch, buildRenameSpeakerPatch } from '@/lib/diarization/speakerEdits';
import {
  buildConfirmedSpeakerPatch,
  buildRejectedSuggestionPatch,
  hasFiniteNonZeroNorm,
  l2Normalize,
  runningMeanEmbedding,
} from '@/lib/diarization/voiceprints';
import { SpeakerProfileOwnerAlreadyExistsError } from '@/data/local/notesRepository';
import {
  buildActionSystemPrompt,
  isDefaultGenerateNotesAction,
} from '@/lib/notes/generateNotesPrompt';
import { buildMeetingNotesInput } from '@/lib/notes/meetingNotesInput';
import { mapUtterancesToSegments } from '@/lib/notes/cloudMeetingSegments';
import { DEFAULT_MEETING_TITLE } from '@/lib/notes/meetingConstants';
import { generateLocalMeetingNotes } from '@/lib/notes/localMeetingNotes';
import {
  getLocalReasoningReadiness,
  isLocalReasoningRequired,
  shouldUseLocalReasoning,
} from '@/lib/localReasoning';
import { promptLocalReasoningFallback } from '@/lib/localReasoningFallback';
import {
  getCalendarParticipantEmails,
  parseCalendarParticipants,
} from '@/lib/calendar/meetingContext';
import { makeContentHash } from '@/lib/utils';
import { logTranscriptionCompleted } from '@/lib/appsflyer';
import { ReasoningService } from '@/services/reasoning/ReasoningService';
import type {
  EnrollVoiceProfileInput,
  ReenrollVoiceProfileInput,
} from '@/services/diarization/VoiceprintService';
import {
  VOICE_ENROLLMENT_DIARIZER_MODEL_REQUIRED,
  VoiceEnrollmentError,
  identifyNoteSpeakers,
} from '@/services/diarization/VoiceprintService';

// These deps are loaded lazily via require() (literal paths, so Metro still bundles them) rather than
// dynamic import(): require keeps the native diarizer/whisper bindings off the cold-start path while
// staying usable under jest, which cannot execute native dynamic import() without --experimental-vm-modules.
/* eslint-disable @typescript-eslint/no-var-requires */
const loadMeetingPipelineDeps = () => {
  const diarizationService =
    require('@/services/diarization/DiarizationService') as typeof import('@/services/diarization/DiarizationService');
  const diarizerModule =
    require('@/lib/diarization/getDiarizer') as typeof import('@/lib/diarization/getDiarizer');
  const localTranscriptionModule =
    require('@/services/transcription/LocalTranscriptionService') as typeof import('@/services/transcription/LocalTranscriptionService');

  return {
    processMeeting: diarizationService.processMeeting,
    getDiarizer: diarizerModule.getDiarizer,
    LocalTranscriptionService: localTranscriptionModule.LocalTranscriptionService,
  };
};

const loadVoiceEnrollmentDeps = () => {
  const voiceprintService =
    require('@/services/diarization/VoiceprintService') as typeof import('@/services/diarization/VoiceprintService');
  const diarizerModule =
    require('@/lib/diarization/getDiarizer') as typeof import('@/lib/diarization/getDiarizer');

  return {
    enrollVoiceProfile: voiceprintService.enrollVoiceProfile,
    reenrollVoiceProfile: voiceprintService.reenrollVoiceProfile,
    getDiarizer: diarizerModule.getDiarizer,
  };
};

const loadVoiceEnrollmentProcessingDeps = () => {
  const speechActivityModule =
    require('@/lib/speechActivity') as typeof import('@/lib/speechActivity');
  const audioToolsModule =
    require('../../modules/audio-tools/src') as typeof import('../../modules/audio-tools/src');

  return {
    analyzeSpeechActivity: speechActivityModule.analyzeSpeechActivity,
    AudioTools: audioToolsModule.AudioTools,
  };
};

const loadDiarizer = () => {
  const diarizerModule =
    require('@/lib/diarization/getDiarizer') as typeof import('@/lib/diarization/getDiarizer');
  return diarizerModule.getDiarizer();
};

const loadLocalTranscriptionService = () => {
  const localTranscriptionModule =
    require('@/services/transcription/LocalTranscriptionService') as typeof import('@/services/transcription/LocalTranscriptionService');
  return localTranscriptionModule.LocalTranscriptionService;
};
/* eslint-enable @typescript-eslint/no-var-requires */

const reloadVoiceProfiles = (): Pick<NotesStore, 'voiceProfiles'> => ({
  voiceProfiles: notesRepository.getSpeakerProfiles(),
});

/** Labels a meeting's speakers from the saved voice profiles; true when any speaker changed. */
const identifyMeetingSpeakers = (
  noteId: number,
  speakerEmbeddingsByLabel: Record<string, number[]>,
  onlyProfileId?: number,
): boolean => {
  const note = notesRepository.getNoteById(noteId);
  const preferredProfileEmails = getCalendarParticipantEmails(
    parseCalendarParticipants(note?.participants ?? null) ?? [],
  );
  const identification = identifyNoteSpeakers(
    noteId,
    speakerEmbeddingsByLabel,
    { repo: notesRepository },
    { preferredProfileEmails, onlyProfileId },
  );
  return identification.updatedSpeakerIds.length > 0;
};

let diarizerModelDownload: Promise<void> | null = null;

// Diarizing with the model missing downloads it natively, into the folder a download
// already running is writing, so it waits for that download first.
const diarizerAfterModelDownload = (diarizer: Diarizer): Diarizer => ({
  ...diarizer,
  diarize: async (wavUri, numberOfSpeakers) => {
    await diarizerModelDownload?.catch(() => undefined);
    return diarizer.diarize(wavUri, numberOfSpeakers);
  },
});

const DEFAULT_FOLDER_ID = 1;
const MEETINGS_FOLDER_NAME = 'meetings';

export type CreateMeetingNoteContext = {
  expectedSpeakerCount?: number;
  calendarEventId?: string | null;
  title?: string | null;
  participants?: CalendarParticipant[] | null;
  /** Defaults to true (on-device path). Cloud realtime meetings have no diarization. */
  diarizationEnabled?: boolean;
  /** The folder the meeting was started from. */
  folderId?: number;
  /** The team space the meeting was started from, when no folder was open. */
  spaceId?: number;
};

const resolveMeetingFolderId = (folders: Folder[]): number => {
  const meetingsFolder = folders.find(
    (folder) => folder.name.trim().toLowerCase() === MEETINGS_FOLDER_NAME,
  );
  const fallbackFolder = folders.find((folder) => folder.isDefault) ?? folders[0];

  return meetingsFolder?.id ?? fallbackFolder?.id ?? DEFAULT_FOLDER_ID;
};

/**
 * A meeting goes where it was started: that folder, or that team space. Anywhere else it
 * goes to the personal Meetings folder. So does a meeting started in a team space this
 * device no longer has, and a Private-mode one, since a private note can't be shared.
 */
const createMeetingNoteRow = (title: string, context: CreateMeetingNoteContext): Note => {
  const canFileInTeamSpace = (spaceId: number | null): boolean =>
    useProcessingModeStore.getState().activeMode !== 'private' &&
    spacesRepository.listSpaces().some(({ id, kind }) => id === spaceId && kind === 'team');
  if (context.folderId != null) {
    const folder = notesRepository.getFolders().find(({ id }) => id === context.folderId);
    if (
      folder &&
      (folder.spaceId === spacesRepository.getPrivateSpace().id ||
        canFileInTeamSpace(folder.spaceId))
    ) {
      return notesRepository.createNote(title, '', folder.id);
    }
  } else if (context.spaceId != null && canFileInTeamSpace(context.spaceId)) {
    return notesRepository.createNote(title, '', undefined, context.spaceId);
  }
  return notesRepository.createNote(
    title,
    '',
    resolveMeetingFolderId(notesRepository.getPrivateFolders()),
  );
};

const assertDiarizerModelReadyForEnrollment = async (
  getDiarizer: ReturnType<typeof loadVoiceEnrollmentDeps>['getDiarizer'],
): Promise<void> => {
  if (!(await getDiarizer().isModelDownloaded())) {
    throw new VoiceEnrollmentError(
      VOICE_ENROLLMENT_DIARIZER_MODEL_REQUIRED,
      'Download the diarization model before enrolling a voice profile.',
    );
  }
};

const canUseCloudForMeetingNote = (note: Note | null | undefined): note is Note => {
  if (
    !useAuthStore.getState().user &&
    useConfigStore.getState().config?.inference?.notes?.mode !== 'providers'
  )
    return false;
  // Local Mode's meetings are private notes; note formatting follows its own selection otherwise.
  return !!note && !note.deletedAt && note.noteType === 'meeting' && note.isPrivate !== 1;
};

const autoGenerateMeetingNotes = async (noteId: number): Promise<void> => {
  const note = notesRepository.getNoteById(noteId);
  if (!note || note.deletedAt || note.noteType !== 'meeting') return;
  // Generated notes the user already has (edited, or from an action they ran) are never replaced
  // automatically, e.g. by retrying a transcript; the Enhanced tab marks them stale instead.
  if (note.enhancedContent?.trim()) return;

  const action = notesRepository.getActions().find(isDefaultGenerateNotesAction);
  if (!action) return;

  const segments = notesRepository.getSegments(noteId);
  if (segments.length === 0) return;

  const transcript = formatTranscriptForExport({
    title: note.calendarEventId ? undefined : note.title,
    segments,
    speakers: notesRepository.getSpeakers(noteId),
    suppressUnlabeledSpeakerNames: true,
  });
  const generationInput = buildMeetingNotesInput({
    rawNotes: note.content,
    transcript,
    meetingContext: note.calendarEventId
      ? {
          eventTitle: note.title,
          participants: parseCalendarParticipants(note.participants ?? null) ?? [],
        }
      : undefined,
  });
  const contentHash = makeContentHash(generationInput);
  if (!generationInput.trim() || note.enhancedAtContentHash === contentHash) return;

  const routing = { isPrivateNote: note.isPrivate === 1 };
  const canUseCloud = canUseCloudForMeetingNote(note);
  const notesMode = useConfigStore.getState().config?.inference?.notes?.mode;
  // On-Device notes take the chunked local path: a whole meeting rarely fits
  // the on-device context in one request.
  const canUseLocal =
    notesMode === 'local'
      ? (await getLocalReasoningReadiness()).status === 'ready'
      : (notesMode !== 'providers' || !canUseCloud) && (await shouldUseLocalReasoning(routing));
  const systemPrompt = buildActionSystemPrompt({
    actionPrompt: action.prompt,
    inputKind: 'meeting-transcript',
    isDefaultGenerateNotesAction: isDefaultGenerateNotesAction(action),
  });

  const writeGeneratedText = (generatedText: string) => {
    // The user may have run an action or written notes while these were generated.
    if (!generatedText.trim() || notesRepository.getNoteById(noteId)?.enhancedContent?.trim()) {
      return;
    }
    notesRepository.updateNote(noteId, {
      enhancedContent: generatedText,
      enhancementPrompt: action.prompt,
      enhancedAtContentHash: contentHash,
    });
  };

  const generateCloudOnce = async () => {
    const result = await ReasoningService.processText({
      inferenceScope: 'notes',
      text: generationInput,
      systemPrompt,
      temperature: 0.3,
      routing: {
        ...routing,
        allowCloudFallback: true,
      },
    });
    writeGeneratedText(result.text);
  };

  const captureError = (error: unknown) => {
    Sentry.captureException(error, { tags: { feature: 'meeting-auto-notes' } });
  };

  if (!canUseCloud && !canUseLocal) {
    if (isLocalReasoningRequired(routing)) {
      const readiness = await getLocalReasoningReadiness();
      const signedIn = !!useAuthStore.getState().user;
      promptLocalReasoningFallback({
        readiness,
        signedIn,
        onEnableLocal: async () => {
          try {
            await autoGenerateMeetingNotes(noteId);
          } catch (error) {
            captureError(error);
          }
        },
        onUseCloudOnce: signedIn
          ? async () => {
              try {
                await generateCloudOnce();
              } catch (error) {
                captureError(error);
              }
            }
          : undefined,
      });
    }
    return;
  }

  const generatedText = canUseLocal
    ? await generateLocalMeetingNotes(noteId, { actionPrompt: action.prompt })
    : (
        await ReasoningService.processText({
          inferenceScope: 'notes',
          text: generationInput,
          systemPrompt,
          temperature: 0.3,
          routing: {
            ...routing,
            allowCloudFallback: canUseCloud,
          },
        })
      ).text;

  writeGeneratedText(generatedText);
};

// Shared finalization tail for both meeting paths (local runMeetingPipeline and cloud
// finalizeCloudMeeting): auto-title from the transcript, then the AI summary/cleanup pass.
const finalizeMeetingNoteContent = async (noteId: number): Promise<void> => {
  const currentNote = notesRepository.getNoteById(noteId);
  if (!currentNote || currentNote.deletedAt || currentNote.noteType !== 'meeting') return;

  const canUseCloud = canUseCloudForMeetingNote(currentNote);

  // Auto-title from the transcript, matching the action path and the "Auto-generate Note
  // Titles" setting. A selected calendar title is durable until the user clears it back to
  // the default title state.
  if (useConfigStore.getState().config?.autoGenerateNoteTitle ?? true) {
    const currentTitle = currentNote?.title?.trim() ?? '';
    const calendarTitleBlocksAutoTitle =
      !!currentNote?.calendarEventId &&
      currentTitle.length > 0 &&
      currentTitle !== DEFAULT_MEETING_TITLE;

    if (!calendarTitleBlocksAutoTitle) {
      const transcriptText = notesRepository
        .getSegments(noteId)
        .map((segment) => segment.text)
        .join(' ')
        .trim();
      if (transcriptText) {
        const { deriveLocalTitle, generateNoteTitle } =
          require('@/utils/generateTitle') as typeof import('@/utils/generateTitle');
        const routing = { isPrivateNote: currentNote.isPrivate === 1 };
        const canUseLocalTitle = await shouldUseLocalReasoning(routing);
        const generatedTitle =
          canUseCloud || canUseLocalTitle
            ? await generateNoteTitle(transcriptText, {
                ...routing,
                allowCloudFallback: canUseCloud,
              })
            : '';
        const title = generatedTitle || (!canUseCloud ? deriveLocalTitle(transcriptText) : '');
        if (title) notesRepository.updateNote(noteId, { title });
      }
    }
  }
  await autoGenerateMeetingNotes(noteId).catch((error) => {
    Sentry.captureException(error, { tags: { feature: 'meeting-auto-notes' } });
  });
};

interface NotesStore {
  /** Private-space folders only (see NotesRepository.getPrivateFolders) — every UI folder surface
   * reads this. Team-space content is reached through the Spaces section instead. */
  folders: Folder[];
  /** Folders of the space currently being browsed (activeSpaceId). Kept separate from `folders`,
   * which is private-space only, so team folders never leak into personal folder surfaces. */
  spaceFolders: Folder[];
  folderCounts: Record<number, number>;
  notes: Note[];
  /** All spaces (private + team, excludes soft-deleted) — populated by initialize() and refreshed
   * after every sync pass, mirroring `folders`. */
  spaces: Space[];
  voiceProfiles: SpeakerProfile[];
  meetingSpeakerEmbeddingsByNoteId: Record<number, Record<string, number[]>>;
  activeNoteId: number | null;
  activeFolderId: number | null;
  /** The team space currently being browsed (FoldersScreen's Spaces section), if any. Mutually
   * exclusive with activeFolderId — selecting one clears the other. */
  activeSpaceId: number | null;
  isInitialized: boolean;
  searchQuery: string;
  isSearching: boolean;
  transcriptRevision: number;

  initialize: () => void;
  getNoteById: (id: number) => Note | null;
  loadFolders: () => void;
  loadSpaces: () => void;
  loadNotes: (folderId?: number) => void;
  setActiveNoteId: (id: number | null) => void;
  setActiveFolderId: (id: number | null) => void;
  setActiveSpaceId: (id: number | null) => void;
  setSearchQuery: (query: string) => void;
  createNote: (title?: string, content?: string, folderId?: number) => Note;
  updateNote: (id: number, updates: NoteUpdate) => void;
  deleteNote: (id: number) => void;
  moveNoteToFolder: (noteId: number, folderId: number) => void;
  moveNoteToSpace: (noteId: number, spaceId: number) => void;
  deleteFolderSafe: (id: number) => void;
  /** Creates in the private space unless `spaceId` names a team space to create it inside. */
  createFolder: (name: string, spaceId?: number) => Folder;
  /** Folders of any space, read from the repository. `spaceFolders` only caches the browsed space's. */
  getSpaceFolders: (spaceId: number) => Folder[];
  renameFolder: (id: number, name: string) => void;
  setNotePrivacy: (id: number, isPrivate: boolean) => Promise<void>;
  /** Data source for the conflict banner (see NoteEditorScreen) — the parked 409 row for this note, if any. */
  getConflictedNote: (noteId: number) => ConflictedNote | null;
  /** Keep the local edit; clears the conflict banner. */
  resolveConflictKeepMine: (noteId: number) => void;
  /** Adopt the server's copy; clears the conflict banner. Callers must re-read the note afterward
   * (e.g. via getNoteById) to refresh any locally-held draft — this only updates the repository. */
  resolveConflictUseServer: (noteId: number) => void;
  createMeetingNote: (context?: number | CreateMeetingNoteContext) => Note;
  transitionStatus: (noteId: number, to: TranscriptionStatus) => void;
  runMeetingPipeline: (
    noteId: number,
    wavUri: string,
    expectedSpeakerCount?: number,
  ) => Promise<void>;
  retryMeetingTranscription: (noteId: number) => Promise<void>;
  finalizeCloudMeeting: (
    noteId: number,
    utterances: RealtimeUtterance[],
    elapsedSeconds: number,
  ) => Promise<void>;
  isDiarizerAvailable: () => Promise<boolean>;
  isDiarizerModelReady: () => Promise<boolean>;
  isLocalAsrModelReady: () => Promise<boolean>;
  downloadDiarizerModel: () => Promise<void>;
  isDiarizerModelDownloading: () => boolean;
  deleteDiarizerModel: () => Promise<void>;
  getNoteSegments: (noteId: number) => Segment[];
  getNoteSpeakers: (noteId: number) => Speaker[];
  loadVoiceProfiles: () => void;
  enrollVoiceProfile: (input: EnrollVoiceProfileInput) => Promise<SpeakerProfile>;
  reenrollVoiceProfile: (input: ReenrollVoiceProfileInput) => Promise<SpeakerProfile>;
  updateVoiceProfile: (
    profileId: number,
    updates: { displayName?: string; email?: string | null },
  ) => void;
  deleteVoiceProfile: (profileId: number) => void;
  deleteAllVoiceProfiles: () => void;
  confirmSpeakerSuggestion: (
    noteId: number,
    speakerId: number,
    meetingEmbedding?: number[],
  ) => void;
  rejectSpeakerSuggestion: (noteId: number, speakerId: number) => void;
  renameSpeaker: (noteId: number, speakerId: number, displayName: string) => void;
  /** Makes a speaker from a meeting just processed on this device your voice profile. */
  claimSpeakerAsMe: (noteId: number, speakerId: number) => void;
  /**
   * Labels a meeting processed since launch with a newly added or retrained voice profile,
   * leaving speakers already linked to another profile alone.
   */
  relabelMeetingSpeakers: (noteId: number, profileId: number) => void;
  mergeSpeakers: (noteId: number, sourceSpeakerId: number, targetSpeakerId: number) => void;
}

export const useNotesStore = create<NotesStore>((set, get) => ({
  folders: [],
  spaceFolders: [],
  folderCounts: {},
  notes: [],
  spaces: [],
  voiceProfiles: [],
  meetingSpeakerEmbeddingsByNoteId: {},
  activeNoteId: null,
  activeFolderId: null,
  activeSpaceId: null,
  isInitialized: false,
  searchQuery: '',
  isSearching: false,
  transcriptRevision: 0,

  initialize: () => {
    const folders = notesRepository.getPrivateFolders();
    const folderCounts = notesRepository.getFolderCounts();
    const defaultFolder = folders.find((f) => f.isDefault) ?? folders[0];
    const notes = defaultFolder ? notesRepository.getNotesByFolder(defaultFolder.id) : [];
    const voiceProfiles = notesRepository.getSpeakerProfiles();
    const spaces = spacesRepository.listSpaces();
    set({
      folders,
      folderCounts,
      notes,
      spaces,
      voiceProfiles,
      activeFolderId: defaultFolder?.id ?? null,
      isInitialized: true,
    });
  },

  getNoteById: (id) => {
    const note = notesRepository.getNoteById(id);
    return note && !note.deletedAt ? note : null;
  },

  loadFolders: () => {
    const { activeSpaceId } = get();
    set({
      folders: notesRepository.getPrivateFolders(),
      folderCounts: notesRepository.getFolderCounts(),
      // A sync pass can add or remove folders in the space on screen, so refresh
      // those alongside the personal ones.
      ...(activeSpaceId != null
        ? { spaceFolders: notesRepository.getFoldersBySpace(activeSpaceId) }
        : {}),
    });
  },

  loadSpaces: () => {
    set({ spaces: spacesRepository.listSpaces() });
  },

  loadNotes: (folderId) => {
    if (folderId != null) {
      set({ notes: notesRepository.getNotesByFolder(folderId) });
      return;
    }
    const { activeFolderId, activeSpaceId } = get();
    if (activeFolderId != null) {
      set({ notes: notesRepository.getNotesByFolder(activeFolderId) });
    } else if (activeSpaceId != null) {
      set({ notes: notesRepository.getSpaceNotesWithoutFolder(activeSpaceId) });
    } else {
      set({ notes: notesRepository.getAllNotes() });
    }
  },

  setActiveNoteId: (id) => set({ activeNoteId: id }),

  setActiveFolderId: (id) => {
    set({
      activeFolderId: id,
      activeSpaceId: null,
      activeNoteId: null,
      searchQuery: '',
      isSearching: false,
    });
    if (id != null) {
      set({ notes: notesRepository.getNotesByFolder(id) });
    } else {
      set({ notes: notesRepository.getAllNotes() });
    }
  },

  setActiveSpaceId: (id) => {
    set({
      activeSpaceId: id,
      activeFolderId: null,
      activeNoteId: null,
      searchQuery: '',
      isSearching: false,
    });
    set({
      spaceFolders: id != null ? notesRepository.getFoldersBySpace(id) : [],
      notes:
        id != null ? notesRepository.getSpaceNotesWithoutFolder(id) : notesRepository.getAllNotes(),
    });
  },

  setSearchQuery: (query) => {
    const { activeFolderId } = get();
    if (query.trim()) {
      const notes = notesRepository.searchNotes(query, activeFolderId ?? undefined);
      set({ searchQuery: query, isSearching: true, notes });
    } else {
      set({ searchQuery: '', isSearching: false });
      get().loadNotes();
    }
  },

  createNote: (title = 'Untitled', content = '', folderId) => {
    const { activeFolderId, activeSpaceId } = get();
    // Browsing a space (mutually exclusive with browsing a folder): the note
    // belongs to that space, not to the personal default folder.
    const note =
      folderId == null && activeSpaceId != null
        ? notesRepository.createNote(title, content, undefined, activeSpaceId)
        : notesRepository.createNote(title, content, folderId ?? activeFolderId ?? 1);

    if (useProcessingModeStore.getState().activeMode === 'private') {
      notesRepository.setNotePrivacy(note.id, true);
    }

    get().loadNotes();
    get().loadFolders();
    return note;
  },

  updateNote: (id, updates) => {
    notesRepository.updateNote(id, updates);
    get().loadNotes();
  },

  deleteNote: (id) => {
    notesRepository.deleteNote(id);
    const { activeNoteId, notes, meetingSpeakerEmbeddingsByNoteId } = get();
    if (activeNoteId === id) {
      const remaining = notes.filter((n) => n.id !== id);
      set({ activeNoteId: remaining[0]?.id ?? null });
    }
    if (id in meetingSpeakerEmbeddingsByNoteId) {
      const next = { ...meetingSpeakerEmbeddingsByNoteId };
      delete next[id];
      set({ meetingSpeakerEmbeddingsByNoteId: next });
    }
    get().loadNotes();
    get().loadFolders();
  },

  getSpaceFolders: (spaceId) => notesRepository.getFoldersBySpace(spaceId),

  moveNoteToFolder: (noteId, folderId) => {
    notesRepository.moveNoteToFolder(noteId, folderId);
    get().loadNotes();
    get().loadFolders();
  },

  moveNoteToSpace: (noteId, spaceId) => {
    notesRepository.moveNoteToSpace(noteId, spaceId);
    get().loadNotes();
    get().loadFolders();
  },

  getConflictedNote: (noteId) =>
    notesRepository.listConflictedNotes().find((c) => c.id === noteId) ?? null,

  resolveConflictKeepMine: (noteId) => {
    notesRepository.resolveConflictKeepMine(noteId);
    get().loadNotes();
  },

  resolveConflictUseServer: (noteId) => {
    notesRepository.resolveConflictUseServer(noteId);
    get().loadNotes();
  },

  deleteFolderSafe: (id) => {
    // Deleting a folder deletes the notes inside it — the server's own cascade.
    // The repository journals both so a refused push can undo the whole thing.
    notesRepository.deleteFolderCascade(id);
    const { activeFolderId } = get();
    get().loadFolders();
    if (activeFolderId === id) {
      const folders = get().folders;
      const defaultFolder = folders.find((f) => f.isDefault) ?? folders[0];
      get().setActiveFolderId(defaultFolder?.id ?? null);
    } else {
      get().loadNotes();
    }
  },

  createFolder: (name, spaceId) => {
    const folder = notesRepository.createFolder(name, spaceId);
    get().loadFolders();
    return folder;
  },

  renameFolder: (id, name) => {
    notesRepository.renameFolder(id, name);
    get().loadFolders();
  },

  setNotePrivacy: async (id, isPrivate) => {
    if (!isPrivate) {
      const note = notesRepository.getNoteById(id);
      if (note?.isPrivate === 1) {
        // Keep old cleanup work durable before publishing under a fresh identity.
        queuePrivateNoteDeletion(note);
        notesRepository.setNotePrivacy(id, false);
      }
      get().loadNotes();
      return;
    }
    const { checkpoint, dispose } = createSyncContext();
    try {
      // Opt-out is immediate. Retain identifiers until deletion is acknowledged,
      // including a create already in flight whose remote id has not arrived yet.
      notesRepository.setNotePrivacy(id, true);
      const note = notesRepository.getNoteById(id);
      if (note?.isPrivate === 1 && (note.remoteId || note.clientNoteId)) {
        await deletePrivateNoteCloudCopy(note, checkpoint);
      }
    } catch (error) {
      // A later publication supersedes this toggle; its retired ID remains queued.
      if (notesRepository.getNoteById(id)?.isPrivate === 1) throw error;
    } finally {
      dispose();
      get().loadNotes();
    }
  },

  createMeetingNote: (input) => {
    const context: CreateMeetingNoteContext =
      typeof input === 'number' ? { expectedSpeakerCount: input } : (input ?? {});
    const title = context.title?.trim() || DEFAULT_MEETING_TITLE;
    const participants =
      context.participants === undefined || context.participants === null
        ? null
        : JSON.stringify(context.participants);
    const note = createMeetingNoteRow(title, context);
    notesRepository.updateNoteMeta(note.id, {
      noteType: 'meeting',
      diarizationEnabled: context.diarizationEnabled === false ? 0 : 1,
      expectedSpeakerCount: context.expectedSpeakerCount ?? null,
    });
    if (context.calendarEventId) {
      notesRepository.updateNoteCalendarContext(note.id, {
        calendarEventId: context.calendarEventId,
        participants,
      });
    }
    get().transitionStatus(note.id, 'recording'); // idle -> recording via the guarded boundary
    if (useProcessingModeStore.getState().activeMode === 'private') {
      notesRepository.setNotePrivacy(note.id, true);
    }
    get().loadNotes();
    get().loadFolders();
    return note;
  },

  transitionStatus: (noteId, to) => {
    const from = notesRepository.getTranscriptionStatus(noteId);
    assertTransition(from, to); // throws on an illegal jump
    notesRepository.setTranscriptionStatus(noteId, to);
    get().loadNotes();
  },

  runMeetingPipeline: async (noteId, wavUri, expectedSpeakerCount) => {
    const { processMeeting, getDiarizer, LocalTranscriptionService } = loadMeetingPipelineDeps();
    notesRepository.updateNoteMeta(noteId, { sourceFile: wavUri });
    try {
      const result = await processMeeting(
        // The facade picks the engine + best downloaded model from the user's language
        // selection, same routing as the dictation path.
        { noteId, wavUri, expectedSpeakerCount, language: getPreferredTranscriptionLanguage() },
        {
          transcribe: (uri, opts) =>
            LocalTranscriptionService.transcribe(uri, {
              language: opts.language,
              wordTimestamps: opts.wordTimestamps,
            }),
          diarizer: diarizerAfterModelDownload(getDiarizer()),
          repo: notesRepository,
        },
      );
      if (notesRepository.getSegments(noteId).some((segment) => segment.text.trim())) {
        logTranscriptionCompleted({ source: 'meeting', provider: 'local' });
      }
      set((state) => ({
        meetingSpeakerEmbeddingsByNoteId: {
          ...state.meetingSpeakerEmbeddingsByNoteId,
          [noteId]: result.speakerEmbeddingsByLabel,
        },
      }));
      if (identifyMeetingSpeakers(noteId, result.speakerEmbeddingsByLabel)) {
        set((state) => ({ transcriptRevision: state.transcriptRevision + 1 }));
      }
      await finalizeMeetingNoteContent(noteId);
    } finally {
      get().loadNotes();
    }
  },

  retryMeetingTranscription: async (noteId) => {
    const note = notesRepository.getNoteById(noteId);
    if (!note || note.deletedAt) {
      throw new Error('Note not found');
    }
    if (!note.sourceFile || !isManagedMeetingAudioUri(noteId, note.sourceFile)) {
      throw new Error('Original audio is no longer available for this note.');
    }
    await get().runMeetingPipeline(noteId, note.sourceFile, note.expectedSpeakerCount ?? undefined);
  },

  finalizeCloudMeeting: async (noteId, utterances, elapsedSeconds) => {
    try {
      get().transitionStatus(noteId, 'transcribing'); // recording -> transcribing
      const segments = mapUtterancesToSegments(utterances, elapsedSeconds).map((segment) => ({
        ...segment,
        noteId,
      }));
      notesRepository.replaceSegments(noteId, segments);
      get().transitionStatus(noteId, 'done'); // transcribing -> done (cloud skips diarizing)
      if (segments.some((segment) => segment.text?.trim())) {
        logTranscriptionCompleted({ source: 'meeting', provider: 'cloud' });
      }
      await finalizeMeetingNoteContent(noteId);
    } finally {
      get().loadNotes();
    }
  },

  isDiarizerAvailable: async () => loadDiarizer().isAvailable(),

  // A download in flight has created some model files, which reads as downloaded.
  isDiarizerModelReady: async () =>
    diarizerModelDownload === null && loadDiarizer().isModelDownloaded(),

  // True only if the local ASR model the meeting path would route to is actually downloaded.
  isLocalAsrModelReady: async () => {
    const LocalTranscriptionService = loadLocalTranscriptionService();
    if (!LocalTranscriptionService.isAvailable()) return false;
    return LocalTranscriptionService.isReadyForLanguage();
  },

  // Shared, so a second caller can't start another download into the same model folder.
  downloadDiarizerModel: () => {
    diarizerModelDownload ??= loadDiarizer()
      .downloadModel()
      .finally(() => {
        diarizerModelDownload = null;
      });
    return diarizerModelDownload;
  },
  isDiarizerModelDownloading: () => diarizerModelDownload !== null,

  deleteDiarizerModel: async () => {
    await loadDiarizer().deleteModel();
  },

  getNoteSegments: (noteId) => notesRepository.getSegments(noteId),
  getNoteSpeakers: (noteId) => notesRepository.getSpeakers(noteId),
  loadVoiceProfiles: () => {
    set(reloadVoiceProfiles());
  },
  enrollVoiceProfile: async (input) => {
    const { enrollVoiceProfile, getDiarizer } = loadVoiceEnrollmentDeps();
    await assertDiarizerModelReadyForEnrollment(getDiarizer);
    const { analyzeSpeechActivity, AudioTools } = loadVoiceEnrollmentProcessingDeps();
    const profile = await enrollVoiceProfile(input, {
      diarizer: getDiarizer(),
      analyzeSpeechActivity,
      audioTools: AudioTools,
      repo: notesRepository,
    });
    set(reloadVoiceProfiles());
    return profile;
  },
  reenrollVoiceProfile: async (input) => {
    const { reenrollVoiceProfile, getDiarizer } = loadVoiceEnrollmentDeps();
    await assertDiarizerModelReadyForEnrollment(getDiarizer);
    const { analyzeSpeechActivity, AudioTools } = loadVoiceEnrollmentProcessingDeps();
    const profile = await reenrollVoiceProfile(input, {
      diarizer: getDiarizer(),
      analyzeSpeechActivity,
      audioTools: AudioTools,
      repo: notesRepository,
    });
    set(reloadVoiceProfiles());
    return profile;
  },
  updateVoiceProfile: (profileId, updates) => {
    const patch: Partial<SpeakerProfile> = {};
    if (updates.displayName !== undefined) {
      const trimmed = updates.displayName.trim();
      if (!trimmed) return;
      patch.displayName = trimmed;
    }
    if (updates.email !== undefined) {
      const trimmed = updates.email?.trim() ?? '';
      patch.email = trimmed.length > 0 ? trimmed : null;
    }
    if (Object.keys(patch).length === 0) return;
    notesRepository.updateSpeakerProfile(profileId, patch);
    set(reloadVoiceProfiles());
  },
  deleteVoiceProfile: (profileId) => {
    notesRepository.deleteSpeakerProfile(profileId);
    set((state) => ({
      ...reloadVoiceProfiles(),
      transcriptRevision: state.transcriptRevision + 1,
    }));
  },
  deleteAllVoiceProfiles: () => {
    notesRepository.deleteAllSpeakerProfiles();
    set((state) => ({
      voiceProfiles: [],
      transcriptRevision: state.transcriptRevision + 1,
    }));
  },
  confirmSpeakerSuggestion: (noteId, speakerId, meetingEmbedding) => {
    const speaker = notesRepository.getSpeakers(noteId).find((row) => row.id === speakerId);
    if (!speaker?.profileId) return;
    const profile = notesRepository.getSpeakerProfileById(speaker.profileId);
    if (!profile) return;

    const patch = buildConfirmedSpeakerPatch(speaker, profile);
    if (Object.keys(patch).length === 0) return;

    notesRepository.updateSpeaker(speaker.id, patch);

    const resolvedEmbedding =
      meetingEmbedding ?? get().meetingSpeakerEmbeddingsByNoteId[noteId]?.[speaker.speakerLabel];

    if (resolvedEmbedding) {
      const embedding = runningMeanEmbedding(
        profile.embedding,
        profile.sampleCount,
        resolvedEmbedding,
        1,
      );
      if (embedding.length > 0) {
        notesRepository.updateSpeakerProfile(profile.id, {
          embedding,
          sampleCount: profile.sampleCount + 1,
        });
      }
    }

    set((state) => ({
      ...reloadVoiceProfiles(),
      transcriptRevision: state.transcriptRevision + 1,
    }));
  },
  rejectSpeakerSuggestion: (noteId, speakerId) => {
    const speaker = notesRepository.getSpeakers(noteId).find((row) => row.id === speakerId);
    if (!speaker) return;
    const patch = buildRejectedSuggestionPatch(speaker);
    if (Object.keys(patch).length === 0) return;
    notesRepository.updateSpeaker(speaker.id, patch);
    set((state) => ({ transcriptRevision: state.transcriptRevision + 1 }));
  },
  renameSpeaker: (noteId, speakerId, displayName) => {
    if (!displayName.trim()) return;
    const speaker = notesRepository.getSpeakers(noteId).find((row) => row.id === speakerId);
    if (!speaker) throw new Error('Speaker not found');
    const patch = buildRenameSpeakerPatch(speaker, displayName);
    if (Object.keys(patch).length === 0) return;
    notesRepository.updateSpeaker(speaker.id, patch);
    set((state) => ({ transcriptRevision: state.transcriptRevision + 1 }));
  },
  claimSpeakerAsMe: (noteId, speakerId) => {
    if (notesRepository.getSpeakerProfiles().some((profile) => profile.isOwner === 1)) {
      throw new SpeakerProfileOwnerAlreadyExistsError();
    }
    // A retry rewrites the speakers under new labels before it replaces the samples.
    if (notesRepository.getTranscriptionStatus(noteId) !== 'done') {
      throw new Error('This meeting is still being processed.');
    }
    const speaker = notesRepository.getSpeakers(noteId).find((row) => row.id === speakerId);
    if (!speaker) throw new Error('Speaker not found');
    // Only held in memory for meetings processed since the app started.
    const embeddings = get().meetingSpeakerEmbeddingsByNoteId[noteId] ?? {};
    const embedding = embeddings[speaker.speakerLabel];
    if (!hasFiniteNonZeroNorm(embedding)) {
      throw new Error("This meeting's voice sample is no longer available.");
    }

    const profile = notesRepository.createOwnerProfileForSpeaker(
      speaker.id,
      {
        displayName: 'Me',
        embedding: l2Normalize(embedding),
        sampleCount: 1,
        consentAt: new Date().toISOString(),
      },
      buildRenameSpeakerPatch(speaker, 'Me'),
    );
    set((state) => ({
      ...reloadVoiceProfiles(),
      transcriptRevision: state.transcriptRevision + 1,
    }));
    // The claim is saved; labelling the rest of the meeting is a bonus that must not undo it.
    try {
      get().relabelMeetingSpeakers(noteId, profile.id);
    } catch (error) {
      Sentry.captureException(error, { tags: { feature: 'voice-setup' } });
    }
  },
  relabelMeetingSpeakers: (noteId, profileId) => {
    const embeddings = get().meetingSpeakerEmbeddingsByNoteId[noteId];
    if (!embeddings || !identifyMeetingSpeakers(noteId, embeddings, profileId)) return;
    set((state) => ({ transcriptRevision: state.transcriptRevision + 1 }));
  },
  mergeSpeakers: (noteId, sourceSpeakerId, targetSpeakerId) => {
    if (sourceSpeakerId === targetSpeakerId) {
      throw new Error('Cannot merge a speaker into itself');
    }
    const rows = notesRepository.getSpeakers(noteId);
    const source = rows.find((row) => row.id === sourceSpeakerId);
    const target = rows.find((row) => row.id === targetSpeakerId);
    if (!source) throw new Error('Source speaker not found');
    if (!target) throw new Error('Target speaker not found');
    notesRepository.mergeSpeakers(noteId, source.id, target.id, buildMergeTargetPatch(target));
    set((state) => ({ transcriptRevision: state.transcriptRevision + 1 }));
  },
}));