feat(expert-consultation): add banner and modal with HubSpot form integration

main/src/db/__tests__/reconcile-from-store.test.ts

@@ -82,6 +82,9 @@ vi.mock('../../graceful-exit', () => ({
 vi.mock('../../newsletter', () => ({
   newsletterStore: createMockStore('newsletter'),
 }))
+vi.mock('../../expert-consultation', () => ({
+  expertConsultationStore: createMockStore('expert-consultation'),
+}))
 
 import { reconcileFromStore } from '../reconcile-from-store'
 
@@ -122,6 +125,26 @@ describe('reconcileFromStore', () => {
     )
   })
 
+  it('syncs expert consultation settings from electron-store to SQLite', () => {
+    mockStoreData['expert-consultation'] = {
+      expertConsultationSubmitted: true,
+      expertConsultationDismissedAt: '2026-02-20T00:00:00.000Z',
+    }
+
+    reconcileFromStore()
+
+    const settings = testDb.prepare('SELECT * FROM settings').all() as {
+      key: string
+      value: string
+    }[]
+    const settingsMap = new Map(settings.map((s) => [s.key, s.value]))
+
+    expect(settingsMap.get('expertConsultationSubmitted')).toBe('true')
+    expect(settingsMap.get('expertConsultationDismissedAt')).toBe(
+      '2026-02-20T00:00:00.000Z'
+    )
+  })
+
   it('syncs feature flags from electron-store to SQLite', () => {
     mockStoreData['feature-flags'] = {
       feature_flag_meta_optimizer: true,

main/src/db/reconcile-from-store.ts

@@ -20,6 +20,7 @@ import { telemetryStore } from '../telemetry-store'
 import { autoUpdateStore } from '../auto-update'
 import { quitConfirmationStore } from '../quit-confirmation'
 import { newsletterStore } from '../newsletter'
+import { expertConsultationStore } from '../expert-consultation'
 import { featureFlagStore } from '../feature-flags/flags'
 import { chatSettingsStore } from '../chat/settings-storage'
 import { threadsStore } from '../chat/threads-storage'
@@ -46,6 +47,21 @@ function syncSettings(): void {
 
   const newsletterDismissedAt = newsletterStore.get('newsletterDismissedAt', '')
   writeSetting('newsletterDismissedAt', newsletterDismissedAt)
+
+  const expertConsultationSubmitted = expertConsultationStore.get(
+    'expertConsultationSubmitted',
+    false
+  )
+  writeSetting(
+    'expertConsultationSubmitted',
+    String(expertConsultationSubmitted)
+  )
+
+  const expertConsultationDismissedAt = expertConsultationStore.get(
+    'expertConsultationDismissedAt',
+    ''
+  )
+  writeSetting('expertConsultationDismissedAt', expertConsultationDismissedAt)
 }
 
 function syncFeatureFlags(): void {

main/src/expert-consultation.ts

@@ -0,0 +1,67 @@
+import Store from 'electron-store'
+import log from './logger'
+import { writeSetting } from './db/writers/settings-writer'
+import { readSetting } from './db/readers/settings-reader'
+import { getFeatureFlag } from './feature-flags/flags'
+import { featureFlagKeys } from '../../utils/feature-flags'
+
+interface ExpertConsultationStore {
+  expertConsultationSubmitted: boolean
+  expertConsultationDismissedAt: string
+}
+
+export interface ExpertConsultationState {
+  submitted: boolean
+  dismissedAt: string
+}
+
+export const expertConsultationStore = new Store<ExpertConsultationStore>({
+  name: 'expert-consultation',
+  defaults: {
+    expertConsultationSubmitted: false,
+    expertConsultationDismissedAt: '',
+  },
+})
+
+export function getExpertConsultationState(): ExpertConsultationState {
+  if (process.env.TOOLHIVE_E2E === 'true') {
+    return { submitted: true, dismissedAt: '' }
+  }
+
+  if (getFeatureFlag(featureFlagKeys.SQLITE_READS_SETTINGS)) {
+    try {
+      const submitted = readSetting('expertConsultationSubmitted')
+      const dismissedAt = readSetting('expertConsultationDismissedAt')
+      if (submitted !== undefined) {
+        return {
+          submitted: submitted === 'true',
+          dismissedAt: dismissedAt ?? '',
+        }
+      }
+    } catch (err) {
+      log.error('[DB] SQLite read failed, falling back to electron-store:', err)
+    }
+  }
+  return {
+    submitted: expertConsultationStore.get('expertConsultationSubmitted'),
+    dismissedAt: expertConsultationStore.get('expertConsultationDismissedAt'),
+  }
+}
+
+export function setExpertConsultationSubmitted(submitted: boolean): void {
+  expertConsultationStore.set('expertConsultationSubmitted', submitted)
+  try {
+    writeSetting('expertConsultationSubmitted', String(submitted))
+  } catch (err) {
+    log.error('[DB] Failed to dual-write expertConsultationSubmitted:', err)
+  }
+}
+
+export function setExpertConsultationDismissedAt(dismissedAt: string): void {
+  expertConsultationStore.set('expertConsultationDismissedAt', dismissedAt)
+  try {
+    writeSetting('expertConsultationDismissedAt', dismissedAt)
+  } catch (err) {
+    log.error('[DB] Failed to dual-write expertConsultationDismissedAt:', err)
+  }
+}

main/src/ipc-handlers/app.ts

@@ -16,6 +16,11 @@ import {
   setNewsletterSubscribed,
   setNewsletterDismissedAt,
 } from '../newsletter'
+import {
+  getExpertConsultationState,
+  setExpertConsultationSubmitted,
+  setExpertConsultationDismissedAt,
+} from '../expert-consultation'
 import { updateTrayStatus } from '../system-tray'
 import { isToolhiveRunning } from '../toolhive-manager'
 
@@ -63,6 +68,18 @@ export function register() {
     setNewsletterDismissedAt(dismissedAt)
   )
 
+  ipcMain.handle('get-expert-consultation-state', () =>
+    getExpertConsultationState()
+  )
+  ipcMain.handle(
+    'set-expert-consultation-submitted',
+    (_e, submitted: boolean) => setExpertConsultationSubmitted(submitted)
+  )
+  ipcMain.handle(
+    'set-expert-consultation-dismissed-at',
+    (_e, dismissedAt: string) => setExpertConsultationDismissedAt(dismissedAt)
+  )
+
   ipcMain.handle(
     'get-main-log-content',
     async (): Promise<string | undefined> => {

main/src/tests/expert-consultation.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const storeDefaults: Record<string, unknown> = {
+  expertConsultationSubmitted: false,
+  expertConsultationDismissedAt: '',
+}
+
+const { mockStoreInstance, mockWriteSetting } = vi.hoisted(() => ({
+  mockStoreInstance: {
+    get: vi.fn(),
+    set: vi.fn(),
+  },
+  mockWriteSetting: vi.fn(),
+}))
+
+vi.mock('@sentry/electron/main', () => ({
+  startSpan: vi.fn((_opts: unknown, cb: (span: unknown) => unknown) =>
+    cb({ setStatus: vi.fn(), setAttribute: vi.fn(), setAttributes: vi.fn() })
+  ),
+}))
+
+vi.mock('electron-store', () => ({
+  default: vi.fn(function ElectronStore() {
+    return mockStoreInstance
+  }),
+}))
+
+vi.mock('../logger', () => ({
+  default: {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}))
+
+vi.mock('../db/writers/settings-writer', () => ({
+  writeSetting: mockWriteSetting,
+}))
+
+vi.mock('../db/readers/settings-reader', () => ({
+  readSetting: vi.fn(),
+}))
+
+vi.mock('../feature-flags/flags', () => ({
+  getFeatureFlag: vi.fn(() => false),
+}))
+
+import {
+  getExpertConsultationState,
+  setExpertConsultationSubmitted,
+  setExpertConsultationDismissedAt,
+} from '../expert-consultation'
+
+describe('expert-consultation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockStoreInstance.get.mockImplementation(
+      (key: string, defaultValue?: unknown) =>
+        defaultValue ?? storeDefaults[key]
+    )
+  })
+
+  describe('getExpertConsultationState', () => {
+    it('returns state from the store', () => {
+      mockStoreInstance.get
+        .mockReturnValueOnce(true)
+        .mockReturnValueOnce('2026-01-01T00:00:00.000Z')
+
+      const state = getExpertConsultationState()
+
+      expect(state).toEqual({
+        submitted: true,
+        dismissedAt: '2026-01-01T00:00:00.000Z',
+      })
+      expect(mockStoreInstance.get).toHaveBeenCalledWith(
+        'expertConsultationSubmitted'
+      )
+      expect(mockStoreInstance.get).toHaveBeenCalledWith(
+        'expertConsultationDismissedAt'
+      )
+    })
+
+    it('returns defaults when store is empty', () => {
+      const state = getExpertConsultationState()
+
+      expect(state).toEqual({ submitted: false, dismissedAt: '' })
+    })
+  })
+
+  describe('setExpertConsultationSubmitted', () => {
+    it('writes to both electron-store and SQLite', () => {
+      setExpertConsultationSubmitted(true)
+
+      expect(mockStoreInstance.set).toHaveBeenCalledWith(
+        'expertConsultationSubmitted',
+        true
+      )
+      expect(mockWriteSetting).toHaveBeenCalledWith(
+        'expertConsultationSubmitted',
+        'true'
+      )
+    })
+
+    it('does not throw when SQLite write fails', () => {
+      mockWriteSetting.mockImplementation(() => {
+        throw new Error('DB write failed')
+      })
+
+      expect(() => setExpertConsultationSubmitted(true)).not.toThrow()
+      expect(mockStoreInstance.set).toHaveBeenCalledWith(
+        'expertConsultationSubmitted',
+        true
+      )
+    })
+  })
+
+  describe('setExpertConsultationDismissedAt', () => {
+    it('writes to both electron-store and SQLite', () => {
+      const timestamp = '2026-03-18T10:00:00.000Z'
+      setExpertConsultationDismissedAt(timestamp)
+
+      expect(mockStoreInstance.set).toHaveBeenCalledWith(
+        'expertConsultationDismissedAt',
+        timestamp
+      )
+      expect(mockWriteSetting).toHaveBeenCalledWith(
+        'expertConsultationDismissedAt',
+        timestamp
+      )
+    })
+
+    it('does not throw when SQLite write fails', () => {
+      mockWriteSetting.mockImplementation(() => {
+        throw new Error('DB write failed')
+      })
+
+      expect(() =>
+        setExpertConsultationDismissedAt('2026-03-18T10:00:00.000Z')
+      ).not.toThrow()
+    })
+  })
+})

preload/src/api/app.ts

@@ -23,6 +23,15 @@ export const appApi = {
   setNewsletterDismissedAt: (dismissedAt: string): Promise<void> =>
     ipcRenderer.invoke('set-newsletter-dismissed-at', dismissedAt),
 
+  getExpertConsultationState: (): Promise<{
+    submitted: boolean
+    dismissedAt: string
+  }> => ipcRenderer.invoke('get-expert-consultation-state'),
+  setExpertConsultationSubmitted: (submitted: boolean): Promise<void> =>
+    ipcRenderer.invoke('set-expert-consultation-submitted', submitted),
+  setExpertConsultationDismissedAt: (dismissedAt: string): Promise<void> =>
+    ipcRenderer.invoke('set-expert-consultation-dismissed-at', dismissedAt),
+
   getMainLogContent: () => ipcRenderer.invoke('get-main-log-content'),
 
   isMac: process.platform === 'darwin',
@@ -45,6 +54,12 @@ export interface AppAPI {
   }>
   setNewsletterSubscribed: (subscribed: boolean) => Promise<void>
   setNewsletterDismissedAt: (dismissedAt: string) => Promise<void>
+  getExpertConsultationState: () => Promise<{
+    submitted: boolean
+    dismissedAt: string
+  }>
+  setExpertConsultationSubmitted: (submitted: boolean) => Promise<void>
+  setExpertConsultationDismissedAt: (dismissedAt: string) => Promise<void>
   getMainLogContent: () => Promise<string>
   isMac: boolean
   isWindows: boolean