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)

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",

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,15 @@ 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 { getSetting } = await import('./database')
+    return transcriptionActiveInfo(
+      getActiveTranscriptionInfo(),
+      await listInstalled(),
+      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-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,84 @@ 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' },
+      ['ggerganov/whisper.cpp/base'],
+      '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('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 }
+    ])
+  })
+})
+
 describe('engineForActiveModel', () => {
   const entries = [
     { id: 'ggml-base', files: [{ name: 'ggml-base.bin' }] }, // whisper (no engine field)

src/main/transcription/select.ts

@@ -7,13 +7,15 @@
 //                          interim, so ticks don't reload the model each call.
 // Everything that turns audio into text depends on this seam, never on a concrete
 // engine module: adding an engine is a new entry here + a new TranscriptionService.
-import type { TranscriptionService } from './types'
+import type { TranscriptionService, TranscribeOptions } from './types'
 import { transcriptionService as whisper } from './whisper-cli'
 import { parakeetTranscription as parakeet } from './parakeet-cli'
 import { whisperServerTranscription as whisperResident, whisperServer } from './whisper-server'
 import { getActiveModal } from '../active-models'
 import { modelsByKind } from '@offgrid/models'
+import { transcriptionLanguages, type SpeechLanguage } from '@offgrid/speech'
 import type { ManagedRuntime } from '../runtime-manager'
+import { getSetting } from '../database'
 // The pure engine classifiers live in a LEAF module (classify.ts) so the CLIs can import
 // them without forming a load-time cycle back through select (which reads the CLI
 // singletons at module scope). Re-exported here so existing importers/tests keep working.
@@ -112,7 +114,52 @@ export function getActiveTranscription(): TranscriptionService {
     getActiveModal('transcription'),
     modelsByKind('transcription')
   )
-  return getTranscription(engine)
+  return withConfiguredTranscriptionLanguage(
+    getTranscription(engine),
+    getSetting('sttLanguage', 'auto')
+  )
+}
+
+/** Apply the user's language hint at the shared transcription seam. An explicit
+ *  call-site hint still wins, so specialized import flows can override it. */
+export function withConfiguredTranscriptionLanguage(
+  service: TranscriptionService,
+  language: string
+): TranscriptionService {
+  return {
+    isAvailable: () => service.isAvailable(),
+    transcribe: (input: { path: string }, opts?: TranscribeOptions) =>
+      service.transcribe(input, { language, ...opts })
+  }
+}
+
+/** Keep a stored language only while the active engine/model supports it. */
+export function resolveConfiguredTranscriptionLanguage(
+  configuredLanguage: string,
+  languages: readonly SpeechLanguage[]
+): string {
+  return languages.some((candidate) => candidate.code === configuredLanguage)
+    ? configuredLanguage
+    : languages[0]?.code ?? 'auto'
+}
+
+export function transcriptionActiveInfo(
+  info: ReturnType<typeof getActiveTranscriptionInfo>,
+  installedIds: readonly string[],
+  configuredLanguage: string
+): ReturnType<typeof getActiveTranscriptionInfo> & {
+  language: string
+  languages: readonly SpeechLanguage[]
+  options: ReturnType<typeof transcriptionModelOptions>
+} {
+  const installed = modelsByKind('transcription').filter((entry) => installedIds.includes(entry.id))
+  const languages = transcriptionLanguages(info.engine, info.modelId)
+  return {
+    ...info,
+    language: resolveConfiguredTranscriptionLanguage(configuredLanguage, languages),
+    languages,
+    options: transcriptionModelOptions(info.modelId, installed)
+  }
 }
 
 /** The engine actually used for a requested one, after the whisper fallback. Single

src/preload/index.ts

@@ -511,6 +511,8 @@ const offGridApi = {
     engine: 'whisper' | 'parakeet' | 'whisper-resident'
     modelId: string | null
     label: string
+    language: string
+    languages: { code: string; label: string }[]
     options: { id: string | null; name: string; active: boolean }[]
   }> => ipcRenderer.invoke('transcription:active-info'),
 

src/renderer/src/App.tsx

@@ -811,8 +811,8 @@ function AppContent() {
   ]
   // One way in to a screen, used by the sidebar and by the command palette: switching screens also
   // drops whatever row was selected in the old one, so a stale detail pane never rides along.
-  const goToView = (view: ViewMode): void => {
-    setNavigationSubroute(null)
+  const goToView = (view: ViewMode, subroute: string | null = null): void => {
+    setNavigationSubroute(view === 'devices' ? subroute : null)
     setSettingsSection(null)
     setViewMode(view)
     setSelectedSessionId(null)
@@ -865,12 +865,26 @@ function AppContent() {
         onOpenHit={handleOpenHit}
         onSeeAll={openSearch}
         /* The sidebar IS the list of screens - the palette searches that, never a second copy. */
-        screens={[...mainNav, ...bottomNav].map(({ label, view, locked }) => ({
-          label,
-          view,
-          locked
-        }))}
-        onGoTo={(view) => goToView(view as ViewMode)}
+        screens={[
+          ...[...mainNav, ...bottomNav].map(({ label, view, locked }) => ({
+            label,
+            view,
+            locked
+          })),
+          {
+            label: 'Activity',
+            view: 'devices',
+            subroute: 'activity',
+            locked: !isPro && proActivation !== 'entitlement-bootstrap'
+          },
+          {
+            label: 'Files',
+            view: 'devices',
+            subroute: 'files',
+            locked: !isPro && proActivation !== 'entitlement-bootstrap'
+          }
+        ]}
+        onGoTo={(view, subroute) => goToView(view as ViewMode, subroute ?? null)}
       />
       {/* Recording indicator — auto-records detected meetings; always visible. */}
       {(rec.recording || rec.busy) && (