diff --git a/src-tauri/Cargo.lock b/src-tauri/Cargo.lock
index 269e43b..2729933 100644
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@@ -717,7 +717,7 @@ dependencies = [
 
 [[package]]
 name = "dikt"
-version = "1.25.0"
+version = "1.26.0"
 dependencies = [
  "arboard",
  "async-trait",
diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs
index 32fa1c3..5cfae11 100644
--- a/src-tauri/src/commands.rs
+++ b/src-tauri/src/commands.rs
@@ -6,7 +6,7 @@ use crate::meeting::{
 };
 use crate::settings::AppSettings;
 use crate::state::AppState;
-use crate::transcription_history::{HistoryPage, HistoryStats};
+use crate::transcription_history::{HistoryPage, HistoryStats, TranscriptionHistoryItem};
 
 #[derive(serde::Serialize, Clone)]
 struct AudioLevelPayload {
@@ -163,6 +163,14 @@ pub fn get_transcription_history_stats(today_start_ms: i64) -> Result<HistorySta
     crate::transcription_history::history_stats(today_start_ms)
 }
 
+#[tauri::command]
+pub fn update_transcription_history_item(
+    id: String,
+    text: String,
+) -> Result<TranscriptionHistoryItem, String> {
+    crate::transcription_history::update_item(&id, &text)
+}
+
 #[tauri::command]
 pub fn delete_transcription_history_item(id: String) -> Result<(), String> {
     crate::transcription_history::delete_item(&id)
diff --git a/src-tauri/src/db.rs b/src-tauri/src/db.rs
index cfaf362..f94dd13 100644
--- a/src-tauri/src/db.rs
+++ b/src-tauri/src/db.rs
@@ -74,6 +74,7 @@ fn open_database(db_path: &Path, app_dir: &Path) -> Result<Connection, String> {
         .map_err(|error| format!("Failed to open database '{}': {error}", db_path.display()))?;
     configure_connection(&conn)?;
     create_schema(&conn)?;
+    ensure_history_columns(&conn)?;
     migrate_json_if_needed(&mut conn, app_dir)?;
     Ok(conn)
 }
@@ -98,7 +99,8 @@ fn create_schema(conn: &Connection) -> Result<(), String> {
             duration_secs REAL,
             language TEXT,
             mode_name TEXT,
-            original_text TEXT
+            original_text TEXT,
+            edited_at_ms INTEGER
         );
         CREATE INDEX IF NOT EXISTS idx_history_created_at
             ON transcription_history(created_at_ms DESC);
@@ -138,6 +140,44 @@ fn create_schema(conn: &Connection) -> Result<(), String> {
     .map_err(|error| format!("Failed to create database schema: {error}"))
 }
 
+/// Adds columns introduced after the initial schema to pre-existing databases.
+/// `CREATE TABLE IF NOT EXISTS` never alters an existing table, so each column
+/// added later needs an idempotent `ALTER TABLE` guarded by a column-existence check.
+fn ensure_history_columns(conn: &Connection) -> Result<(), String> {
+    if !table_has_column(conn, "transcription_history", "edited_at_ms")? {
+        conn.execute(
+            "ALTER TABLE transcription_history ADD COLUMN edited_at_ms INTEGER",
+            [],
+        )
+        .map_err(|error| {
+            format!("Failed to add edited_at_ms column to transcription_history: {error}")
+        })?;
+    }
+    Ok(())
+}
+
+fn table_has_column(conn: &Connection, table: &str, column: &str) -> Result<bool, String> {
+    let mut stmt = conn
+        .prepare(&format!("PRAGMA table_info({table})"))
+        .map_err(|error| format!("Failed to inspect {table} columns: {error}"))?;
+    let mut rows = stmt
+        .query([])
+        .map_err(|error| format!("Failed to inspect {table} columns: {error}"))?;
+    while let Some(row) = rows
+        .next()
+        .map_err(|error| format!("Failed to read {table} columns: {error}"))?
+    {
+        // PRAGMA table_info columns: cid(0), name(1), type(2), notnull(3), dflt_value(4), pk(5)
+        let name: String = row
+            .get(1)
+            .map_err(|error| format!("Failed to read {table} column name: {error}"))?;
+        if name == column {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
 fn migrate_json_if_needed(conn: &mut Connection, app_dir: &Path) -> Result<(), String> {
     let version: i64 = conn
         .query_row("PRAGMA user_version", [], |row| row.get(0))
@@ -545,6 +585,48 @@ mod tests {
         fs::remove_dir_all(app_dir).unwrap();
     }
 
+    #[test]
+    fn ensure_history_columns_adds_edited_at_to_legacy_tables() {
+        let conn = Connection::open_in_memory().unwrap();
+        // The transcription_history schema as shipped before edited_at_ms existed.
+        conn.execute_batch(
+            r#"
+            CREATE TABLE transcription_history (
+                id TEXT PRIMARY KEY,
+                text TEXT NOT NULL,
+                created_at_ms INTEGER NOT NULL,
+                duration_secs REAL,
+                language TEXT,
+                mode_name TEXT,
+                original_text TEXT
+            );
+            "#,
+        )
+        .unwrap();
+        assert!(!table_has_column(&conn, "transcription_history", "edited_at_ms").unwrap());
+
+        ensure_history_columns(&conn).unwrap();
+        assert!(table_has_column(&conn, "transcription_history", "edited_at_ms").unwrap());
+
+        // Idempotent: running again on an already-migrated table is a harmless no-op.
+        ensure_history_columns(&conn).unwrap();
+
+        // Existing rows get NULL for the new column (i.e. "never edited").
+        conn.execute(
+            "INSERT INTO transcription_history (id, text, created_at_ms) VALUES ('x', 'hi', 1)",
+            [],
+        )
+        .unwrap();
+        let edited: Option<i64> = conn
+            .query_row(
+                "SELECT edited_at_ms FROM transcription_history WHERE id = 'x'",
+                [],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(edited, None);
+    }
+
     #[test]
     fn meeting_status_processing_round_trips() {
         assert_eq!(meeting_status_to_str(&MeetingStatus::Processing), "processing");
diff --git a/src-tauri/src/main.rs b/src-tauri/src/main.rs
index b7c9a1c..83a4101 100644
--- a/src-tauri/src/main.rs
+++ b/src-tauri/src/main.rs
@@ -118,6 +118,7 @@ fn main() {
             commands::fetch_provider_models,
             commands::get_transcription_history,
             commands::get_transcription_history_stats,
+            commands::update_transcription_history_item,
             commands::delete_transcription_history_item,
             commands::clear_transcription_history,
             commands::start_meeting,
diff --git a/src-tauri/src/transcription_history.rs b/src-tauri/src/transcription_history.rs
index e5ac58f..a9cf29d 100644
--- a/src-tauri/src/transcription_history.rs
+++ b/src-tauri/src/transcription_history.rs
@@ -20,6 +20,10 @@ pub struct TranscriptionHistoryItem {
     pub mode_name: Option<String>,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub original_text: Option<String>,
+    /// Set when the user manually edits the transcription; doubles as the
+    /// "was edited" flag and the timestamp of the edit. `None` for untouched items.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub edited_at_ms: Option<i64>,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -79,7 +83,7 @@ pub fn load_history_page(
             let mut stmt = conn
                 .prepare(
                     r#"
-                    SELECT id, text, created_at_ms, duration_secs, language, mode_name, original_text
+                    SELECT id, text, created_at_ms, duration_secs, language, mode_name, original_text, edited_at_ms
                     FROM transcription_history
                     WHERE text LIKE ?1 OR original_text LIKE ?1 OR mode_name LIKE ?1
                     ORDER BY created_at_ms DESC
@@ -103,7 +107,7 @@ pub fn load_history_page(
             let mut stmt = conn
                 .prepare(
                     r#"
-                    SELECT id, text, created_at_ms, duration_secs, language, mode_name, original_text
+                    SELECT id, text, created_at_ms, duration_secs, language, mode_name, original_text, edited_at_ms
                     FROM transcription_history
                     ORDER BY created_at_ms DESC
                     LIMIT ?1 OFFSET ?2
@@ -174,11 +178,67 @@ pub fn append_item(params: AppendItemParams) -> Result<(), String> {
         language: params.language,
         mode_name: params.mode_name,
         original_text: params.original_text,
+        edited_at_ms: None,
     };
 
     crate::db::with_connection(|conn| crate::db::insert_history_item(conn, &item))
 }
 
+/// Replaces the text of an existing history item with a manual edit.
+///
+/// Stamps `edited_at_ms` so the UI can show the entry was edited, and preserves
+/// the original recognizer output in `original_text` the first time an item is
+/// edited (`COALESCE(original_text, text)` keeps any pre-existing value, e.g. the
+/// raw text saved when an AI mode reformatted the dictation). Returns the updated row.
+pub fn update_item(id: &str, text: &str) -> Result<TranscriptionHistoryItem, String> {
+    let now_ms = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .map_err(|e| e.to_string())?
+        .as_millis() as i64;
+
+    crate::db::with_connection(|conn| update_item_in(conn, id, text, now_ms))
+}
+
+fn update_item_in(
+    conn: &rusqlite::Connection,
+    id: &str,
+    text: &str,
+    now_ms: i64,
+) -> Result<TranscriptionHistoryItem, String> {
+    let text = text.trim();
+    if text.is_empty() {
+        return Err("Transcription text cannot be empty.".to_string());
+    }
+
+    let affected = conn
+        .execute(
+            r#"
+            UPDATE transcription_history
+            SET original_text = COALESCE(original_text, text),
+                text = ?2,
+                edited_at_ms = ?3
+            WHERE id = ?1
+            "#,
+            params![id, text, now_ms],
+        )
+        .map_err(|error| format!("Failed to update transcription history item: {error}"))?;
+
+    if affected == 0 {
+        return Err(format!("Transcription history item '{id}' not found."));
+    }
+
+    conn.query_row(
+        r#"
+        SELECT id, text, created_at_ms, duration_secs, language, mode_name, original_text, edited_at_ms
+        FROM transcription_history
+        WHERE id = ?1
+        "#,
+        params![id],
+        history_item_from_row,
+    )
+    .map_err(|error| format!("Failed to load updated transcription history item: {error}"))
+}
+
 pub fn delete_item(id: &str) -> Result<(), String> {
     crate::db::with_connection(|conn| {
         conn.execute(
@@ -218,6 +278,7 @@ fn history_item_from_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<Transcript
         language: row.get("language")?,
         mode_name: row.get("mode_name")?,
         original_text: row.get("original_text")?,
+        edited_at_ms: row.get("edited_at_ms")?,
     })
 }
 
@@ -238,7 +299,8 @@ mod tests {
                 duration_secs REAL,
                 language TEXT,
                 mode_name TEXT,
-                original_text TEXT
+                original_text TEXT,
+                edited_at_ms INTEGER
             );
             CREATE INDEX idx_history_created_at ON transcription_history(created_at_ms DESC);
             "#,
@@ -258,6 +320,7 @@ mod tests {
                 language: Some("en".to_string()),
                 mode_name: Some("Clean Draft".to_string()),
                 original_text: None,
+                edited_at_ms: None,
             },
         )
         .unwrap();
@@ -271,7 +334,7 @@ mod tests {
 
         let mut stmt = conn
             .prepare(
-                "SELECT id, text, created_at_ms, duration_secs, language, mode_name, original_text FROM transcription_history ORDER BY created_at_ms DESC",
+                "SELECT id, text, created_at_ms, duration_secs, language, mode_name, original_text, edited_at_ms FROM transcription_history ORDER BY created_at_ms DESC",
             )
             .unwrap();
         let rows = stmt
@@ -306,6 +369,53 @@ mod tests {
         assert_eq!(remaining.as_deref(), Some("b"));
     }
 
+    #[test]
+    fn editing_preserves_first_original_text_and_stamps_edited_at() {
+        let conn = test_conn();
+        // `insert` stores original_text = None, so `text` is the raw recognizer output.
+        insert(&conn, "a", "raw transcription", 1);
+
+        let first = update_item_in(&conn, "a", "  first edit  ", 100).unwrap();
+        assert_eq!(first.text, "first edit", "edited text is trimmed and saved");
+        assert_eq!(
+            first.original_text.as_deref(),
+            Some("raw transcription"),
+            "raw recognizer output is preserved into original_text on first edit"
+        );
+        assert_eq!(first.edited_at_ms, Some(100));
+
+        let second = update_item_in(&conn, "a", "second edit", 200).unwrap();
+        assert_eq!(second.text, "second edit");
+        assert_eq!(
+            second.original_text.as_deref(),
+            Some("raw transcription"),
+            "the preserved original is never overwritten by later edits"
+        );
+        assert_eq!(second.edited_at_ms, Some(200));
+    }
+
+    #[test]
+    fn editing_missing_item_is_an_error() {
+        let conn = test_conn();
+        assert!(update_item_in(&conn, "missing", "text", 1).is_err());
+    }
+
+    #[test]
+    fn editing_to_empty_text_is_rejected() {
+        let conn = test_conn();
+        insert(&conn, "a", "raw transcription", 1);
+        assert!(update_item_in(&conn, "a", "   ", 100).is_err());
+        // The original row is left untouched.
+        let text: String = conn
+            .query_row(
+                "SELECT text FROM transcription_history WHERE id = ?1",
+                params!["a"],
+                |row| row.get(0),
+            )
+            .unwrap();
+        assert_eq!(text, "raw transcription");
+    }
+
     #[test]
     fn clear_removes_all_rows() {
         let conn = test_conn();
diff --git a/src/SettingsApp.tsx b/src/SettingsApp.tsx
index fb458c2..77ad4b7 100644
--- a/src/SettingsApp.tsx
+++ b/src/SettingsApp.tsx
@@ -431,6 +431,22 @@ export default function SettingsApp() {
     }
   };
 
+  const updateHistoryItem = async (id: string, text: string) => {
+    try {
+      const updated = await invoke<TranscriptionHistoryItem>('update_transcription_history_item', {
+        id,
+        text,
+      });
+      // Patch in place: editing changes neither ordering nor counts, so a full
+      // reload would only cost a scroll jump.
+      setHistory((items) => items.map((item) => (item.id === id ? updated : item)));
+      notifySuccess('Entry updated.');
+    } catch (err) {
+      notifyError(err, 'Failed to update history entry.');
+      throw err; // keep the inline editor open so the unsaved edit isn't lost
+    }
+  };
+
   const deleteHistoryItem = async (id: string) => {
     try {
       await invoke('delete_transcription_history_item', { id });
@@ -825,6 +841,7 @@ export default function SettingsApp() {
             onSearchQueryChange={(value) => setHistorySearchQuery(value)}
             onPageChange={(page) => void loadHistory(page)}
             onCopy={copyHistoryText}
+            onEdit={updateHistoryItem}
             onDelete={deleteHistoryItem}
             onClearAll={clearHistory}
           />
diff --git a/src/components/Settings/HistoryPage.tsx b/src/components/Settings/HistoryPage.tsx
index 8c7692c..7e2abcb 100644
--- a/src/components/Settings/HistoryPage.tsx
+++ b/src/components/Settings/HistoryPage.tsx
@@ -1,4 +1,4 @@
-import { For, Show, createMemo } from 'solid-js';
+import { For, Show, createMemo, createSignal } from 'solid-js';
 import type { Accessor } from 'solid-js';
 import type { TranscriptionHistoryItem } from '../../types';
 import {
@@ -25,6 +25,9 @@ import {
   ChevronRight,
   Mail,
   Code,
+  Pencil,
+  Check,
+  X,
 } from 'lucide-solid';
 import type { Component } from 'solid-js';
 
@@ -49,6 +52,7 @@ export type HistoryPageProps = {
   onSearchQueryChange: (value: string) => void;
   onPageChange: (page: number) => void;
   onCopy: (text: string) => void;
+  onEdit: (id: string, text: string) => Promise<void>;
   onDelete: (id: string) => void;
   onClearAll: () => void;
 };
@@ -56,41 +60,143 @@ export type HistoryPageProps = {
 function HistoryItem(props: {
   item: TranscriptionHistoryItem;
   onCopy: (text: string) => void;
+  onEdit: (id: string, text: string) => Promise<void>;
   onDelete: (id: string) => void;
 }) {
+  const [editing, setEditing] = createSignal(false);
+  const [draft, setDraft] = createSignal('');
+  const [saving, setSaving] = createSignal(false);
+
   const hasOriginalText = () =>
     props.item.original_text != null && props.item.original_text !== props.item.text;
 
   const isNonEnglish = () =>
     props.item.language != null && props.item.language !== 'english' && props.item.language !== '';
 
+  const autosize = (el: HTMLTextAreaElement) => {
+    el.style.height = 'auto';
+    el.style.height = `${Math.min(el.scrollHeight, 320)}px`;
+  };
+
+  const startEdit = () => {
+    setDraft(props.item.text);
+    setEditing(true);
+  };
+
+  const cancelEdit = () => {
+    setEditing(false);
+    setDraft('');
+  };
+
+  const saveEdit = async () => {
+    const next = draft().trim();
+    if (!next) return; // keep editing \u2014 an empty transcription isn't useful
+    if (next === props.item.text) {
+      cancelEdit();
+      return;
+    }
+    setSaving(true);
+    try {
+      await props.onEdit(props.item.id, next);
+      setEditing(false);
+    } catch {
+      // The handler already surfaced the error; keep the editor open so the
+      // unsaved edit isn't lost and the user can retry.
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const handleKeyDown = (event: KeyboardEvent) => {
+    if (event.key === 'Escape') {
+      event.preventDefault();
+      cancelEdit();
+    } else if (event.key === 'Enter' && (event.metaKey || event.ctrlKey)) {
+      event.preventDefault();
+      void saveEdit();
+    }
+  };
+
   return (
     <div class="group relative rounded-xl p-4 hover:bg-surface-hover transition-colors duration-200 flex flex-col gap-2">
-      <div class="pr-12">
-        <p class={`text-white text-[15px] leading-relaxed ${isNonEnglish() ? 'italic' : ''}`}>
-          {isNonEnglish() && '\u201C'}{props.item.text}{isNonEnglish() && '\u201D'}
-        </p>
-
-        <Show when={hasOriginalText()}>
-          <details class="group/details mt-3">
-            <summary class="cursor-pointer text-xs text-primary font-medium hover:brightness-110 transition-colors list-none flex items-center gap-1 w-fit select-none">
-              Show original
-              <ChevronDown size={12} class="group-open/details:rotate-180 transition-transform" />
-            </summary>
-            <div class="mt-2 p-3 bg-black/20 rounded-md border-l-2 border-white/10 text-gray-500 text-sm break-words relative group/original">
-              {props.item.original_text}
-              <button
-                type="button"
-                onClick={() => props.onCopy(props.item.original_text!)}
-                class="absolute top-2 right-2 p-1 rounded-lg text-gray-600 hover:text-white hover:bg-white/10 transition-colors opacity-0 group-hover/original:opacity-100"
-                title="Copy original text"
-              >
-                <Copy size={14} />
-              </button>
-            </div>
-          </details>
-        </Show>
-      </div>
+      <Show
+        when={editing()}
+        fallback={
+          <div class="pr-12">
+            <p class={`text-white text-[15px] leading-relaxed whitespace-pre-wrap ${isNonEnglish() ? 'italic' : ''}`}>
+              {isNonEnglish() && '\u201C'}{props.item.text}{isNonEnglish() && '\u201D'}
+            </p>
+
+            <Show when={hasOriginalText()}>
+              <details class="group/details mt-3">
+                <summary class="cursor-pointer text-xs text-primary font-medium hover:brightness-110 transition-colors list-none flex items-center gap-1 w-fit select-none">
+                  Show original
+                  <ChevronDown size={12} class="group-open/details:rotate-180 transition-transform" />
+                </summary>
+                <div class="mt-2 p-3 bg-black/20 rounded-md border-l-2 border-white/10 text-gray-500 text-sm break-words relative group/original">
+                  {props.item.original_text}
+                  <button
+                    type="button"
+                    onClick={() => props.onCopy(props.item.original_text!)}
+                    class="absolute top-2 right-2 p-1 rounded-lg text-gray-600 hover:text-white hover:bg-white/10 transition-colors opacity-0 group-hover/original:opacity-100"
+                    title="Copy original text"
+                  >
+                    <Copy size={14} />
+                  </button>
+                </div>
+              </details>
+            </Show>
+          </div>
+        }
+      >
+        <div class="flex flex-col gap-2">
+          <textarea
+            ref={(el) => {
+              // Solid runs ref callbacks before the node is attached, so defer
+              // to a microtask: focus only works and scrollHeight is only
+              // measurable once the textarea is in the DOM.
+              queueMicrotask(() => {
+                autosize(el);
+                el.focus();
+                const end = el.value.length;
+                el.setSelectionRange(end, end);
+              });
+            }}
+            value={draft()}
+            disabled={saving()}
+            onInput={(e) => {
+              setDraft(e.currentTarget.value);
+              autosize(e.currentTarget);
+            }}
+            onKeyDown={handleKeyDown}
+            rows={2}
+            class="w-full resize-none rounded-lg bg-surface-dark border border-white/10 focus:border-primary focus:ring-1 focus:ring-primary text-white text-[15px] leading-relaxed p-3 outline-none transition-colors scrollbar-hide disabled:opacity-50"
+          />
+          <div class="flex items-center gap-2">
+            <button
+              type="button"
+              onClick={() => void saveEdit()}
+              disabled={saving() || draft().trim().length === 0}
+              class="flex items-center gap-1.5 px-3 py-1.5 rounded-lg bg-primary text-black text-sm font-semibold hover:brightness-110 transition-all disabled:opacity-40 disabled:cursor-not-allowed"
+            >
+              <Check size={14} />
+              Save
+            </button>
+            <button
+              type="button"
+              onClick={cancelEdit}
+              disabled={saving()}
+              class="flex items-center gap-1.5 px-3 py-1.5 rounded-lg text-gray-400 text-sm font-medium hover:text-white hover:bg-white/10 transition-colors disabled:opacity-40"
+            >
+              <X size={14} />
+              Cancel
+            </button>
+            <span class="ml-auto text-xs text-gray-600 select-none hidden sm:block">
+              {'\u2318'}/Ctrl+{'\u21B5'} to save \u00B7 Esc to cancel
+            </span>
+          </div>
+        </div>
+      </Show>
 
       <div class="flex items-center gap-4 mt-1 text-xs text-gray-500 select-none">
         <Show when={isNonEnglish()}>
@@ -120,26 +226,46 @@ function HistoryItem(props: {
           <Clock size={12} />
           <span>{formatItemTime(props.item.created_at_ms)}</span>
         </div>
-      </div>
 
-      <div class="absolute right-3 top-3 flex gap-0.5 opacity-0 group-hover:opacity-100 transition-opacity duration-200">
-        <button
-          type="button"
-          onClick={() => props.onCopy(props.item.text)}
-          class="p-1.5 rounded-lg text-gray-500 hover:text-white hover:bg-white/10 transition-colors"
-          title="Copy text"
-        >
-          <Copy size={16} />
-        </button>
-        <button
-          type="button"
-          onClick={() => props.onDelete(props.item.id)}
-          class="p-1.5 rounded-lg text-gray-500 hover:text-red-400 hover:bg-red-500/10 transition-colors"
-          title="Delete entry"
-        >
-          <Trash2 size={16} />
-        </button>
+        <Show when={props.item.edited_at_ms != null}>
+          <div
+            class="flex items-center gap-1 text-gray-500"
+            title={`Edited ${formatExactTime(props.item.edited_at_ms!)}`}
+          >
+            <Pencil size={11} />
+            <span>edited</span>
+          </div>
+        </Show>
       </div>
+
+      <Show when={!editing()}>
+        <div class="absolute right-3 top-3 flex gap-0.5 opacity-0 group-hover:opacity-100 transition-opacity duration-200">
+          <button
+            type="button"
+            onClick={() => props.onCopy(props.item.text)}
+            class="p-1.5 rounded-lg text-gray-500 hover:text-white hover:bg-white/10 transition-colors"
+            title="Copy text"
+          >
+            <Copy size={16} />
+          </button>
+          <button
+            type="button"
+            onClick={startEdit}
+            class="p-1.5 rounded-lg text-gray-500 hover:text-white hover:bg-white/10 transition-colors"
+            title="Edit text"
+          >
+            <Pencil size={16} />
+          </button>
+          <button
+            type="button"
+            onClick={() => props.onDelete(props.item.id)}
+            class="p-1.5 rounded-lg text-gray-500 hover:text-red-400 hover:bg-red-500/10 transition-colors"
+            title="Delete entry"
+          >
+            <Trash2 size={16} />
+          </button>
+        </div>
+      </Show>
     </div>
   );
 }
@@ -338,6 +464,7 @@ export default function HistoryPage(props: HistoryPageProps) {
                         <HistoryItem
                           item={item}
                           onCopy={props.onCopy}
+                          onEdit={props.onEdit}
                           onDelete={props.onDelete}
                         />
                       )}
diff --git a/src/types.ts b/src/types.ts
index 47ebc79..1c96bb1 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -53,6 +53,7 @@ export type TranscriptionHistoryItem = {
   language?: string;
   mode_name?: string;
   original_text?: string;
+  edited_at_ms?: number;
 };
 
 export type TranscriptionHistoryPage = {