feat: add history tab and optional clipboard copying

History:
- New History tab with persistent storage of all dictations
- Each entry stores final text, raw transcription, style, app name, timestamp
- Expandable entries with copy/remove actions and raw transcription diff
- Thread-safe JSON persistence with async lock (max 500 entries)

Clipboard:
- New "Copy to clipboard" toggle in Preferences (default: off)
- Clipboard write only happens when explicitly enabled or when auto-paste needs it
- Status messages updated to reference history instead of clipboard

Author: nicremo

src/main/defaults.ts

@@ -39,6 +39,7 @@ export function createDefaultSettings(): AppSettings {
     cloudLanguage: 'de',
     openaiApiKeyEncrypted: '',
     autoPaste: true,
+    copyToClipboard: false,
     showOverlay: false,
     launchAtLogin: false,
     setupComplete: false,

src/main/dictation.ts

@@ -236,12 +236,18 @@ export async function processDictationAudio({
 
   console.log('[openwhisp:dictation] final', { rewriteFallback: usedRewriteFallback, text: finalText });
 
-  clipboard.writeText(finalText);
+  if (settings.copyToClipboard) {
+    clipboard.writeText(finalText);
+  }
 
   let pasted = false;
   let focusInfo = targetFocus;
 
   if (settings.autoPaste) {
+    if (!settings.copyToClipboard) {
+      clipboard.writeText(finalText);
+    }
+
     setStatus({
       phase: 'pasting',
       title: 'Pasting',
@@ -254,18 +260,19 @@ export async function processDictationAudio({
     pasted = await triggerPaste(focusInfo).catch(() => false);
   }
 
+  const doneTitle = pasted ? 'Pasted' : 'Done';
+  const doneDetail = usedRewriteFallback
+    ? pasted
+      ? 'The raw transcription was pasted because the rewrite model was unavailable.'
+      : 'The raw transcription was saved to history because the rewrite model was unavailable.'
+    : pasted
+      ? 'The refined text was pasted into the active app.'
+      : 'The refined text was saved to history.';
+
   setStatus({
     phase: 'done',
-    title: pasted ? 'Pasted' : 'Copied',
-    detail: usedRewriteFallback
-      ? pasted
-        ? 'The raw transcription was pasted because the rewrite model was unavailable.'
-        : 'The raw transcription is on the clipboard because the rewrite model was unavailable.'
-      : pasted
-        ? 'The refined text was pasted into the active app.'
-        : focusInfo?.appName
-          ? `OpenWhisp copied the text, but it could not paste into ${focusInfo.appName}.`
-          : 'The refined text is on the clipboard.',
+    title: doneTitle,
+    detail: doneDetail,
     preview: finalText,
     rawText,
   });
@@ -280,6 +287,8 @@ export async function processDictationAudio({
     pasted,
     focusInfo,
     transcriptionSource,
+    styleMode: resolved.styleMode,
+    enhancementLevel: resolved.enhancementLevel,
   };
 }
 

src/main/history.ts

@@ -0,0 +1,92 @@
+import { app } from 'electron';
+import { randomUUID } from 'node:crypto';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+import type { EnhancementLevel, HistoryEntry, StyleMode } from '../shared/types';
+
+const HISTORY_FILE = 'history.json';
+const MAX_HISTORY_ENTRIES = 500;
+
+const locks = new Map<string, Promise<void>>();
+
+async function withLock<T>(key: string, fn: () => Promise<T>): Promise<T> {
+  const previous = locks.get(key) ?? Promise.resolve();
+  let resolve: () => void;
+  const current = new Promise<void>((r) => { resolve = r; });
+  locks.set(key, current);
+  await previous;
+  try {
+    return await fn();
+  } finally {
+    resolve!();
+  }
+}
+
+function getHistoryPath(): string {
+  return path.join(app.getPath('userData'), HISTORY_FILE);
+}
+
+export async function loadHistory(): Promise<HistoryEntry[]> {
+  try {
+    const raw = await readFile(getHistoryPath(), 'utf8');
+    return JSON.parse(raw) as HistoryEntry[];
+  } catch {
+    return [];
+  }
+}
+
+async function saveHistory(entries: HistoryEntry[]): Promise<void> {
+  const filePath = getHistoryPath();
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(entries, null, 2)}\n`, 'utf8');
+}
+
+export interface AddHistoryInput {
+  rawText: string;
+  finalText: string;
+  transcriptionSource: 'cloud' | 'local';
+  styleMode: StyleMode;
+  enhancementLevel: EnhancementLevel;
+  appName?: string;
+}
+
+export async function addHistoryEntry(input: AddHistoryInput): Promise<HistoryEntry[]> {
+  return withLock('history', async () => {
+    const entries = await loadHistory();
+
+    entries.unshift({
+      id: randomUUID(),
+      rawText: input.rawText,
+      finalText: input.finalText,
+      transcriptionSource: input.transcriptionSource,
+      styleMode: input.styleMode,
+      enhancementLevel: input.enhancementLevel,
+      appName: input.appName,
+      createdAt: new Date().toISOString(),
+    });
+
+    if (entries.length > MAX_HISTORY_ENTRIES) {
+      entries.length = MAX_HISTORY_ENTRIES;
+    }
+
+    await saveHistory(entries);
+    return entries;
+  });
+}
+
+export async function removeHistoryEntry(id: string): Promise<HistoryEntry[]> {
+  return withLock('history', async () => {
+    const entries = await loadHistory();
+    const filtered = entries.filter((e) => e.id !== id);
+    await saveHistory(filtered);
+    return filtered;
+  });
+}
+
+export async function clearHistory(): Promise<HistoryEntry[]> {
+  return withLock('history', async () => {
+    await saveHistory([]);
+    return [];
+  });
+}

src/main/ipc.ts

@@ -13,6 +13,7 @@ import { testCloudConnection } from './cloud-transcription';
 import { loadAppRules, addAppRule, removeAppRule, updateAppRule } from './app-rules';
 import { loadDictionary, addDictionaryEntry, removeDictionaryEntry, loadCorrections, addCorrection, removeCorrection } from './dictionary';
 import { processDictationAudio } from './dictation';
+import { loadHistory, addHistoryEntry, removeHistoryEntry, clearHistory } from './history';
 import { applyLaunchAtLogin } from './login-item';
 import { pullOllamaModel, listOllamaModels, isOllamaReachable, ensureOllamaRunning } from './ollama';
 import { getFocusInfo } from './native-helper';
@@ -56,6 +57,7 @@ export function registerIpcHandlers(dependencies: IpcDependencies): void {
       dictionary: await loadDictionary(),
       corrections: await loadCorrections(),
       appRules: await loadAppRules(),
+      history: await loadHistory(),
       status: dependencies.getStatus(),
     };
   };
@@ -207,17 +209,37 @@ export function registerIpcHandlers(dependencies: IpcDependencies): void {
 
   ipcMain.handle('dictation:captureTarget', async () => getFocusInfo());
 
-  ipcMain.handle('dictation:processAudio', async (_event, request: DictationRequest) =>
-    processDictationAudio({
+  ipcMain.handle('dictation:processAudio', async (_event, request: DictationRequest) => {
+    const result = await processDictationAudio({
       wavBase64: request.wavBase64,
       settings: dependencies.getSettings(),
       dictionary: await loadDictionary(),
       corrections: await loadCorrections(),
       appRules: await loadAppRules(),
       targetFocus: request.targetFocus,
       setStatus: dependencies.setStatus,
-    }),
-  );
+    });
+
+    await addHistoryEntry({
+      rawText: result.rawText,
+      finalText: result.finalText,
+      transcriptionSource: result.transcriptionSource,
+      styleMode: result.styleMode,
+      enhancementLevel: result.enhancementLevel,
+      appName: result.focusInfo?.appName,
+    }).catch((error) => {
+      console.warn('[openwhisp] Failed to save history entry:', error instanceof Error ? error.message : error);
+    });
+
+    return result;
+  });
+
+  ipcMain.handle('history:remove', async (_event, id: unknown) => {
+    if (typeof id !== 'string') throw new Error('Expected string for history entry id.');
+    return removeHistoryEntry(id);
+  });
+
+  ipcMain.handle('history:clear', async () => clearHistory());
 
   ipcMain.on('dictation:status', (_event, status: AppStatus) => {
     dependencies.setStatus(status);

src/preload/index.ts

@@ -8,6 +8,7 @@ import type {
   DictionaryEntry,
   DictationRequest,
   FocusInfo,
+  HistoryEntry,
   HotkeyEvent,
   UpdateSettingsInput,
 } from '../shared/types';
@@ -44,6 +45,10 @@ const api = {
     ipcRenderer.invoke('appRules:remove', appIdentifier) as Promise<AppRule[]>,
   updateAppRule: (appIdentifier: string, styleMode: string, enhancementLevel: string) =>
     ipcRenderer.invoke('appRules:update', appIdentifier, styleMode, enhancementLevel) as Promise<AppRule[]>,
+  removeHistoryEntry: (id: string) =>
+    ipcRenderer.invoke('history:remove', id) as Promise<HistoryEntry[]>,
+  clearHistory: () =>
+    ipcRenderer.invoke('history:clear') as Promise<HistoryEntry[]>,
   captureFocusTarget: () =>
     ipcRenderer.invoke('dictation:captureTarget') as Promise<FocusInfo>,
   processAudio: (request: DictationRequest) =>

src/renderer/App.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useRef, useState } from 'react';
 import { HugeiconsIcon } from '@hugeicons/react';
-import { Home01Icon, PaintBrush01Icon, CubeIcon, Settings01Icon, BookOpen01Icon } from '@hugeicons/core-free-icons';
+import { Home01Icon, PaintBrush01Icon, CubeIcon, Settings01Icon, BookOpen01Icon, Clock01Icon } from '@hugeicons/core-free-icons';
 
 import { AudioRecorder } from './audio-recorder';
 import logoUrl from './logo.png';
@@ -10,7 +10,7 @@ import type { CloudTranscriptionModel } from '../shared/types';
 
 const OVERLAY_VIEW = window.location.hash === '#overlay';
 
-type Page = 'home' | 'style' | 'models' | 'dictionary' | 'preferences';
+type Page = 'home' | 'style' | 'models' | 'dictionary' | 'history' | 'preferences';
 
 interface LevelOption {
   value: EnhancementLevel;
@@ -482,6 +482,9 @@ function MainView({ bootstrap, status, busyAction, onAction, onRefresh }: {
           <button className={`nav-item${page === 'dictionary' ? ' nav-item-active' : ''}`} onClick={() => setPage('dictionary')}>
             <HugeiconsIcon icon={BookOpen01Icon} size={18} strokeWidth={2} /> Dictionary
           </button>
+          <button className={`nav-item${page === 'history' ? ' nav-item-active' : ''}`} onClick={() => setPage('history')}>
+            <HugeiconsIcon icon={Clock01Icon} size={18} strokeWidth={2} /> History
+          </button>
           <button className={`nav-item${page === 'preferences' ? ' nav-item-active' : ''}`} onClick={() => setPage('preferences')}>
             <HugeiconsIcon icon={Settings01Icon} size={18} strokeWidth={2} /> Preferences
           </button>
@@ -504,6 +507,7 @@ function MainView({ bootstrap, status, busyAction, onAction, onRefresh }: {
         {page === 'style' && <StylePage bootstrap={bootstrap} onAction={onAction} onRefresh={onRefresh} />}
         {page === 'models' && <ModelsPage bootstrap={bootstrap} busyAction={busyAction} onAction={onAction} />}
         {page === 'dictionary' && <DictionaryPage bootstrap={bootstrap} onRefresh={onRefresh} />}
+        {page === 'history' && <HistoryPage bootstrap={bootstrap} onRefresh={onRefresh} />}
         {page === 'preferences' && <PreferencesPage bootstrap={bootstrap} onAction={onAction} />}
       </main>
     </div>
@@ -1037,6 +1041,105 @@ function DictionaryPage({ bootstrap, onRefresh }: { bootstrap: BootstrapState; o
   );
 }
 
+/* ── History ──────────────────────────────────── */
+
+function formatHistoryDate(iso: string): string {
+  const date = new Date(iso);
+  const now = new Date();
+  const isToday = date.toDateString() === now.toDateString();
+  const yesterday = new Date(now);
+  yesterday.setDate(yesterday.getDate() - 1);
+  const isYesterday = date.toDateString() === yesterday.toDateString();
+
+  const time = date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  if (isToday) return `Today, ${time}`;
+  if (isYesterday) return `Yesterday, ${time}`;
+  return `${date.toLocaleDateString([], { day: 'numeric', month: 'short' })}, ${time}`;
+}
+
+function HistoryPage({ bootstrap, onRefresh }: { bootstrap: BootstrapState; onRefresh: () => Promise<BootstrapState> }) {
+  const [expandedId, setExpandedId] = useState<string | null>(null);
+  const history = bootstrap.history;
+
+  const handleRemove = async (id: string) => {
+    await window.openWhisp.removeHistoryEntry(id);
+    await onRefresh();
+  };
+
+  const handleClear = async () => {
+    await window.openWhisp.clearHistory();
+    await onRefresh();
+  };
+
+  const handleCopy = (text: string) => {
+    void navigator.clipboard.writeText(text);
+  };
+
+  return (
+    <div className="page">
+      <div className="page-header">
+        <h2 className="page-title serif">History</h2>
+        <p className="page-desc">Every dictation is saved here automatically.</p>
+      </div>
+
+      <div className="card">
+        <div className="card-head">
+          <h3>Recent dictations</h3>
+          {history.length > 0 && (
+            <button className="btn btn-link btn-muted" onClick={() => void handleClear()}>Clear all</button>
+          )}
+        </div>
+
+        {history.length === 0 && (
+          <p className="empty-state">No dictations yet. Hold the right Option key and start speaking.</p>
+        )}
+
+        {history.map((entry) => {
+          const isExpanded = expandedId === entry.id;
+          const hasRaw = entry.rawText !== entry.finalText;
+          return (
+            <div key={entry.id} className={`history-entry${isExpanded ? ' history-entry-expanded' : ''}`}>
+              <div className="history-entry-header" onClick={() => setExpandedId(isExpanded ? null : entry.id)}>
+                <div className="history-entry-main">
+                  <p className="history-entry-text">{entry.finalText}</p>
+                  <div className="history-entry-meta">
+                    <span className="history-meta-time">{formatHistoryDate(entry.createdAt)}</span>
+                    {entry.appName && <span className="history-meta-tag">{entry.appName}</span>}
+                    <span className="history-meta-tag">{entry.transcriptionSource}</span>
+                  </div>
+                </div>
+                <svg className={`history-chevron${isExpanded ? ' history-chevron-open' : ''}`} width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
+                  <polyline points="6 9 12 15 18 9" />
+                </svg>
+              </div>
+
+              {isExpanded && (
+                <div className="history-entry-detail">
+                  {hasRaw && (
+                    <div className="history-raw-block">
+                      <span className="history-detail-label">Raw transcription</span>
+                      <p className="history-raw-text">{entry.rawText}</p>
+                    </div>
+                  )}
+                  <div className="history-detail-row">
+                    <span className="history-detail-label">Style</span>
+                    <span className="history-detail-value">{entry.styleMode} / {entry.enhancementLevel}</span>
+                  </div>
+                  <div className="history-entry-actions">
+                    <button className="btn btn-sm btn-primary" onClick={() => handleCopy(entry.finalText)}>Copy</button>
+                    {hasRaw && <button className="btn btn-sm btn-secondary" onClick={() => handleCopy(entry.rawText)}>Copy raw</button>}
+                    <button className="btn btn-sm btn-muted" onClick={() => void handleRemove(entry.id)}>Remove</button>
+                  </div>
+                </div>
+              )}
+            </div>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
+
 /* ── Preferences ──────────────────────────────── */
 
 function PreferencesPage({ bootstrap, onAction }: { bootstrap: BootstrapState; onAction: (l: string, a: () => Promise<BootstrapState>) => Promise<void> }) {
@@ -1054,6 +1157,7 @@ function PreferencesPage({ bootstrap, onAction }: { bootstrap: BootstrapState; o
       <div className="card">
         <div className="card-head"><h3>Behavior</h3></div>
         <ToggleRow title="Auto-paste" description="Paste into the active app after rewriting" checked={bootstrap.settings.autoPaste} onChange={(v) => void onAction('settings', () => window.openWhisp.updateSettings({ autoPaste: v }))} />
+        <ToggleRow title="Copy to clipboard" description="Copy the result to your clipboard after each dictation" checked={bootstrap.settings.copyToClipboard} onChange={(v) => void onAction('settings', () => window.openWhisp.updateSettings({ copyToClipboard: v }))} />
         <ToggleRow title="Show overlay" description="Show the dictation badge on screen" checked={bootstrap.settings.showOverlay} onChange={(v) => void onAction('settings', () => window.openWhisp.updateSettings({ showOverlay: v }))} />
         <ToggleRow title="Launch at login" description="Start Openwhisp when you log in" checked={bootstrap.settings.launchAtLogin} onChange={(v) => void onAction('settings', () => window.openWhisp.updateSettings({ launchAtLogin: v }))} />
       </div>