Release 107 feedback: clean desktop chat previews

.github/workflows/ci.yml

@@ -107,6 +107,7 @@ jobs:
           npm --prefix ../shared ci
           npm --prefix ../shared/packages/sync run build
           npm --prefix ../shared/packages/models run build
+          npm --prefix ../shared/packages/speech run build
       - run: npm ci
       # Hard gates: types + the full test suite.
       - name: Typecheck (core)
@@ -116,6 +117,12 @@ jobs:
         if: ${{ hashFiles('pro/tsconfig.json') != '' }}
         timeout-minutes: 6
         run: cd pro && npx tsc --noEmit -p tsconfig.json
+      # npm's Electron install hooks leave sqlite compiled for Electron's ABI. The
+      # Vitest process is plain Node, and some default integration tests open the
+      # real database, so put the native module on Node's ABI before that gate.
+      # The later DB journey script restores the Electron ABI in its EXIT trap.
+      - name: Rebuild SQLite for the Node test runner
+        run: npm rebuild better-sqlite3-multiple-ciphers
       # Runs the full vitest suite AND enforces the coverage ratchet floor
       # (vitest.config.ts `thresholds`) — the same gate as the pre-push hook, so a
       # coverage regression fails CI, not just local pushes. The pro/** threshold

package.json

@@ -59,6 +59,7 @@
     "@offgrid/clipboard": "file:./packages/clipboard",
     "@offgrid/design": "file:./packages/design",
     "@offgrid/models": "file:../shared/packages/models",
+    "@offgrid/speech": "file:../shared/packages/speech",
     "@offgrid/rag": "file:./packages/rag",
     "@offgrid/sync": "file:../shared/packages/sync",
     "@phosphor-icons/react": "^2.1.10",

scripts/hooks/pre-push

@@ -35,6 +35,13 @@ fi
 # So: run each suite, keep its report, gate once on the union. The floors are a RATCHET recording what this
 # branch achieves. Raise them as coverage rises; do not lower them to pass.
 echo "[pre-push] coverage 1/3 — unit + integration"
+# The app keeps SQLite built for Electron. The fast suite also contains real product
+# integrations that open SQLite under Node, so give them Node's ABI before Vitest starts.
+# The DB journey immediately below restores Electron's ABI in its EXIT trap.
+if ! npm rebuild better-sqlite3-multiple-ciphers >/dev/null 2>&1; then
+  echo "[pre-push] BLOCKED: could not rebuild SQLite for the Node test runner."
+  exit 1
+fi
 if ! npm run --silent test:coverage; then
   echo ""
   echo "[pre-push] NOTE: the fast suite reported failures or missed its own thresholds. The aggregate gate"

src/main/__tests__/rag-empty-memory.dbtest.ts

@@ -59,7 +59,7 @@ vi.mock('@lancedb/lancedb', () => ({
   })
 }))
 
-import { getDB } from '../database'
+import { getDB, saveSetting } from '../database'
 import { setupIPC } from '../ipc'
 import { llm } from '../llm'
 import { listProjects } from '../rag/store'
@@ -124,6 +124,23 @@ afterAll(async () => {
 })
 
 describe('rag:chat on an empty memory corpus', () => {
+  it('returns the configured transcription language through the registered IPC path', async () => {
+    saveSetting('sttLanguage', 'hi')
+
+    const handler = handlers.get('transcription:active-info')
+    expect(handler).toBeTypeOf('function')
+    const activeInfo = (await handler!({ sender: { send: () => undefined } })) as {
+      engine: string
+      language: string
+      options: Array<{ active: boolean }>
+    }
+    expect(activeInfo).toMatchObject({ engine: 'whisper', language: 'hi' })
+    expect(activeInfo.options.some(({ active }) => active)).toBe(true)
+
+    const { getActiveTranscription } = await import('../transcription/select')
+    expect(getActiveTranscription().isAvailable()).toBeTypeOf('boolean')
+  })
+
   it('answers without context and releases the chat seam for the next turn', async () => {
     const handler = handlers.get('rag:chat')
     expect(handler).toBeTypeOf('function')

src/main/ipc.ts

@@ -2048,20 +2048,33 @@ export function setupIPC() {
   // Which STT engine + model would run right now (provenance) + the installed transcription
   // models a picker can switch to (via the existing models:set-active-modal — this only lists).
   ipcMain.handle('transcription:active-info', async () => {
-    const { getActiveTranscriptionInfo, transcriptionModelOptions } =
+    const { getActiveTranscriptionInfo, transcriptionActiveInfo } =
       await import('./transcription/select')
-    const { listInstalled } = await import('./models-manager')
-    const { modelsByKind } = await import('@offgrid/models')
-    const info = getActiveTranscriptionInfo()
-    const installedIds = new Set(await listInstalled())
-    const installed = (
-      modelsByKind('transcription') as Array<{
-        id: string
-        name?: string
-        files: Array<{ name: string }>
-      }>
-    ).filter((entry) => installedIds.has(entry.id))
-    return { ...info, options: transcriptionModelOptions(info.modelId, installed) }
+    const { getCatalog } = await import('./models-manager')
+    const { getSetting } = await import('./database')
+    const catalog = await getCatalog()
+    const installed = (catalog.models as Array<{
+      id: string
+      familyId?: string
+      name?: string
+      kind?: string
+      downloaded?: boolean
+      files?: Array<{ name: string; downloaded?: boolean }>
+    }>).filter(
+      (model) =>
+        model.kind === 'transcription' &&
+        (model.downloaded === true || model.files?.every((file) => file.downloaded === true))
+    )
+    return transcriptionActiveInfo(
+      getActiveTranscriptionInfo(),
+      installed.map((model) => ({
+        id: model.id,
+        familyId: model.familyId,
+        name: model.name,
+        files: model.files ?? []
+      })),
+      getSetting('sttLanguage', 'auto')
+    )
   })
 
   // --- Voice input (STT via the active engine: whisper default / Parakeet opt-in) ---

src/main/models-manager.ts

@@ -733,7 +733,13 @@ export async function activateModel(
     kind = getLocalModels().find((m) => m.id === modelId)?.kind
   } else {
     const { CATALOG, resolveHuggingFaceModel } = await import('@offgrid/models')
-    kind = (CATALOG.find((m) => m.id === modelId) ?? (await resolveHuggingFaceModel(modelId)))?.kind
+    const downloaded = reconcileDownloadedModelRegistry(
+      llm.getModelsDir(),
+      CATALOG as unknown as CatalogEntry[]
+    )
+    kind =
+      downloadedVariant(downloaded, modelId)?.kind ??
+      (CATALOG.find((m) => m.id === modelId) ?? (await resolveHuggingFaceModel(modelId)))?.kind
   }
   const modal = modalityForModel(kind)
   return modal ? setActiveModalChoice(modal, modelId) : setActiveModel(modelId)

src/main/models/__tests__/model-download-matrix.integration.test.ts

@@ -222,7 +222,7 @@ describe('model download release matrix', () => {
     expect(dictation.isAvailable()).toBe(true)
     await expect(
       dictation.transcribe({ path: path.join(testRoot, 'synthetic.wav') }, { alreadyWav16k: true })
-    ).resolves.toEqual({ text: 'downloaded model dictation works', language: undefined })
+    ).resolves.toEqual({ text: 'downloaded model dictation works', language: 'en' })
   })
 
   it('keeps a multi-file image model unavailable until the whole runtime stack lands (#21)', async () => {

src/main/models/__tests__/model-transfer-registration.integration.test.ts

@@ -28,6 +28,25 @@ afterAll(() => {
 })
 
 describe('device-transferred model registration', () => {
+  it('activates a transferred Whisper package as transcription, not as the chat LLM', async () => {
+    const primary = 'ggml-small.en.gguf'
+    const primaryBytes = validGguf(10)
+    fs.writeFileSync(path.join(dataDir, 'models', primary), primaryBytes)
+
+    const registered = await manager.registerTransferredModel({
+      id: 'ggerganov/whisper.cpp/small.en',
+      name: 'Whisper Small English',
+      kind: 'transcription',
+      source: 'downloaded',
+      files: [{ name: primary, sizeBytes: primaryBytes.length }]
+    })
+
+    expect(registered.success).toBe(true)
+    await expect(manager.activateModel(registered.id!)).resolves.toEqual({ success: true })
+    expect(manager.getActiveModalities()).toMatchObject({ transcription: registered.id })
+    expect(manager.getActiveModel()).not.toBe(registered.id)
+  })
+
   it('registers a valid vision variant whose files differ from the download catalog', async () => {
     const primary = 'Qwen3.5-0.8B-Q4_0.gguf'
     const projector = 'qwen3.5-0.8b-mmproj-F16.gguf'

src/main/transcription/__tests__/select.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, vi } from 'vitest'
 import {
   pickTranscription,
   engineForActiveModel,
@@ -8,7 +8,10 @@ import {
   catalogEngine,
   modelsByEngine,
   transcriptionProvenance,
-  transcriptionModelOptions
+  transcriptionModelOptions,
+  transcriptionActiveInfo,
+  resolveConfiguredTranscriptionLanguage,
+  withConfiguredTranscriptionLanguage
 } from '../select'
 import type { TranscriptionService } from '../types'
 
@@ -70,6 +73,117 @@ describe('pickTranscription', () => {
   })
 })
 
+describe('withConfiguredTranscriptionLanguage', () => {
+  it('applies the selected language to normal transcription', async () => {
+    const transcribe = vi.fn(async () => ({ text: 'bonjour' }))
+    const configured = withConfiguredTranscriptionLanguage(
+      { isAvailable: () => true, transcribe },
+      'fr'
+    )
+
+    await configured.transcribe({ path: '/tmp/voice.wav' })
+
+    expect(transcribe).toHaveBeenCalledWith(
+      { path: '/tmp/voice.wav' },
+      expect.objectContaining({ language: 'fr' })
+    )
+  })
+
+  it('allows a specialized caller to override the selected language', async () => {
+    const transcribe = vi.fn(async () => ({ text: 'hello' }))
+    const configured = withConfiguredTranscriptionLanguage(
+      { isAvailable: () => true, transcribe },
+      'fr'
+    )
+
+    await configured.transcribe({ path: '/tmp/voice.wav' }, { language: 'en' })
+
+    expect(transcribe).toHaveBeenCalledWith(
+      { path: '/tmp/voice.wav' },
+      expect.objectContaining({ language: 'en' })
+    )
+  })
+})
+
+describe('resolveConfiguredTranscriptionLanguage', () => {
+  const languages = [
+    { code: 'auto', label: 'Auto-detect' },
+    { code: 'hi', label: 'Hindi' }
+  ]
+
+  it('keeps a language supported by the selected transcription model', () => {
+    expect(resolveConfiguredTranscriptionLanguage('hi', languages)).toBe('hi')
+  })
+
+  it('falls back to the model default after switching to an incompatible model', () => {
+    expect(resolveConfiguredTranscriptionLanguage('fr', languages)).toBe('auto')
+    expect(resolveConfiguredTranscriptionLanguage('fr', [])).toBe('auto')
+  })
+})
+
+describe('transcriptionActiveInfo', () => {
+  it('returns the selected language and only installed transcription choices', () => {
+    const result = transcriptionActiveInfo(
+      { engine: 'whisper', modelId: 'ggml-base.bin', label: 'Whisper · Base' },
+      [
+        {
+          id: 'ggerganov/whisper.cpp/base',
+          name: 'Whisper Base',
+          files: [{ name: 'ggml-base.bin' }]
+        }
+      ],
+      'hi'
+    )
+
+    expect(result.language).toBe('hi')
+    expect(result.languages.some((language) => language.code === 'hi')).toBe(true)
+    expect(result.options).toEqual([
+      { id: null, name: 'Whisper (built-in)', active: false },
+      { id: 'ggerganov/whisper.cpp/base', name: 'Whisper Base', active: true }
+    ])
+  })
+
+  it('lists a transferred package by its exact id and matches its active family', () => {
+    const result = transcriptionActiveInfo(
+      { engine: 'whisper', modelId: 'whisper-large-v3', label: 'Whisper · Large' },
+      [
+        {
+          id: 'transferred:whisper-large-v3:q5',
+          familyId: 'whisper-large-v3',
+          name: 'Whisper Large v3 (transferred)',
+          files: [{ name: 'ggml-large-v3-q5.bin' }]
+        }
+      ],
+      'hi'
+    )
+
+    expect(result.options[1]).toEqual({
+      id: 'transferred:whisper-large-v3:q5',
+      name: 'Whisper Large v3 (transferred)',
+      active: true
+    })
+  })
+
+  it('falls back to auto-detect and excludes models that are not installed', () => {
+    const result = transcriptionActiveInfo(
+      { engine: 'whisper', modelId: null, label: 'Whisper · built-in' },
+      [],
+      'unsupported'
+    )
+
+    expect(result.language).toBe('auto')
+    expect(result.options).toEqual([
+      { id: null, name: 'Whisper (built-in)', active: true }
+    ])
+  })
+
+  it('marks built-in Whisper active when the saved model is no longer installed', () => {
+    expect(transcriptionModelOptions('removed-whisper-model', [])).toEqual([
+      { id: null, name: 'Whisper (built-in)', active: true }
+    ])
+  })
+})
+
 describe('engineForActiveModel', () => {
   const entries = [
     { id: 'ggml-base', files: [{ name: 'ggml-base.bin' }] }, // whisper (no engine field)