From fdede4e5ba82479a29bcef182ab63edfdfbbd9af Mon Sep 17 00:00:00 2001
From: Yujong Lee <yujonglee.dev@gmail.com>
Date: Mon, 23 Feb 2026 10:30:26 +0900
Subject: [PATCH 1/2] simplify transcript crate

---
 Cargo.lock                                    | 452 +----------
 crates/transcript/Cargo.toml                  |  22 -
 crates/transcript/examples/cli/app.rs         | 282 -------
 crates/transcript/examples/cli/feed.rs        |  63 --
 crates/transcript/examples/cli/fixture.rs     |  23 -
 crates/transcript/examples/cli/logger.rs      |  41 -
 crates/transcript/examples/cli/main.rs        | 231 ------
 .../examples/cli/provider/cactus.rs           | 258 ------
 .../transcript/examples/cli/provider/cloud.rs | 156 ----
 .../transcript/examples/cli/provider/mod.rs   |   5 -
 .../transcript/examples/cli/renderer/debug.rs | 385 ---------
 .../transcript/examples/cli/renderer/mod.rs   | 109 ---
 .../examples/cli/renderer/transcript.rs       | 228 ------
 crates/transcript/examples/cli/source.rs      |  66 --
 crates/transcript/examples/cli/theme.rs       |  60 --
 crates/transcript/examples/cli/viewport.rs    |  63 --
 crates/transcript/src/accumulator.rs          |  91 +++
 crates/transcript/src/accumulator/channel.rs  | 116 ---
 crates/transcript/src/accumulator/mod.rs      | 735 ------------------
 crates/transcript/src/accumulator/words.rs    | 598 --------------
 crates/transcript/src/id.rs                   |  41 -
 crates/transcript/src/input.rs                |  67 --
 crates/transcript/src/lib.rs                  |  20 +-
 crates/transcript/src/postprocess/mod.rs      |  48 --
 crates/transcript/src/processor.rs            | 272 +++++++
 crates/transcript/src/types.rs                | 112 ++-
 crates/transcript/src/view.rs                 | 588 --------------
 crates/transcript/src/words.rs                | 246 ++++++
 plugins/listener/Cargo.toml                   |   2 +
 plugins/listener2/Cargo.toml                  |   1 +
 30 files changed, 673 insertions(+), 4708 deletions(-)
 delete mode 100644 crates/transcript/examples/cli/app.rs
 delete mode 100644 crates/transcript/examples/cli/feed.rs
 delete mode 100644 crates/transcript/examples/cli/fixture.rs
 delete mode 100644 crates/transcript/examples/cli/logger.rs
 delete mode 100644 crates/transcript/examples/cli/main.rs
 delete mode 100644 crates/transcript/examples/cli/provider/cactus.rs
 delete mode 100644 crates/transcript/examples/cli/provider/cloud.rs
 delete mode 100644 crates/transcript/examples/cli/provider/mod.rs
 delete mode 100644 crates/transcript/examples/cli/renderer/debug.rs
 delete mode 100644 crates/transcript/examples/cli/renderer/mod.rs
 delete mode 100644 crates/transcript/examples/cli/renderer/transcript.rs
 delete mode 100644 crates/transcript/examples/cli/source.rs
 delete mode 100644 crates/transcript/examples/cli/theme.rs
 delete mode 100644 crates/transcript/examples/cli/viewport.rs
 create mode 100644 crates/transcript/src/accumulator.rs
 delete mode 100644 crates/transcript/src/accumulator/channel.rs
 delete mode 100644 crates/transcript/src/accumulator/mod.rs
 delete mode 100644 crates/transcript/src/accumulator/words.rs
 delete mode 100644 crates/transcript/src/id.rs
 delete mode 100644 crates/transcript/src/input.rs
 delete mode 100644 crates/transcript/src/postprocess/mod.rs
 create mode 100644 crates/transcript/src/processor.rs
 delete mode 100644 crates/transcript/src/view.rs
 create mode 100644 crates/transcript/src/words.rs

diff --git a/Cargo.lock b/Cargo.lock
index 1a8cca442a..c28729acfa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1256,15 +1256,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "atomic"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a89cbf775b137e9b968e67227ef7f775587cde3fd31b0d8599dbd0f598a48340"
-dependencies = [
- "bytemuck",
-]
-
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -1588,7 +1579,7 @@ dependencies = [
  "http 0.2.12",
  "http 1.4.0",
  "http-body 0.4.6",
- "lru 0.12.5",
+ "lru",
  "percent-encoding",
  "regex-lite",
  "sha2",
@@ -2907,15 +2898,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
-[[package]]
-name = "castaway"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "cbc"
 version = "0.1.2"
@@ -3348,20 +3330,6 @@ dependencies = [
  "unicode-width 0.2.2",
 ]
 
-[[package]]
-name = "compact_str"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a"
-dependencies = [
- "castaway",
- "cfg-if",
- "itoa",
- "rustversion",
- "ryu",
- "static_assertions",
-]
-
 [[package]]
 name = "compression-codecs"
 version = "0.4.37"
@@ -3857,13 +3825,9 @@ checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b"
 dependencies = [
  "bitflags 2.11.0",
  "crossterm_winapi",
- "derive_more 2.1.1",
  "document-features",
- "mio",
  "parking_lot",
  "rustix 1.1.3",
- "signal-hook",
- "signal-hook-mio",
  "winapi",
 ]
 
@@ -3916,16 +3880,6 @@ dependencies = [
  "typenum",
 ]
 
-[[package]]
-name = "csscolorparser"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2a7d3066da2de787b7f032c736763eb7ae5d355f81a68bab2675a96008b0bf"
-dependencies = [
- "lab",
- "phf 0.11.3",
-]
-
 [[package]]
 name = "cssparser"
 version = "0.29.6"
@@ -4393,12 +4347,6 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26bf8fc351c5ed29b5c2f0cbbac1b209b74f60ecd62e675a998df72c49af5204"
 
-[[package]]
-name = "deltae"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5729f5117e208430e437df2f4843f5e5952997175992d1414f94c57d61e270b4"
-
 [[package]]
 name = "deno_core"
 version = "0.338.0"
@@ -5512,16 +5460,6 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 
-[[package]]
-name = "fancy-regex"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b95f7c0680e4142284cf8b22c14a476e87d61b004a3a0861872b32ef7ead40a2"
-dependencies = [
- "bit-set 0.5.3",
- "regex",
-]
-
 [[package]]
 name = "fancy-regex"
 version = "0.16.2"
@@ -5685,17 +5623,6 @@ dependencies = [
  "flate2",
 ]
 
-[[package]]
-name = "filedescriptor"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d"
-dependencies = [
- "libc",
- "thiserror 1.0.69",
- "winapi",
-]
-
 [[package]]
 name = "filetime"
 version = "0.2.27"
@@ -5725,18 +5652,6 @@ dependencies = [
  "winapi",
 ]
 
-[[package]]
-name = "finl_unicode"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9844ddc3a6e533d62bba727eb6c28b5d360921d5175e9ff0f1e621a5c590a4d5"
-
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
 [[package]]
 name = "fixedbitset"
 version = "0.5.7"
@@ -9427,19 +9342,6 @@ dependencies = [
  "tempfile",
 ]
 
-[[package]]
-name = "instability"
-version = "0.3.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357b7205c6cd18dd2c86ed312d1e70add149aea98e7ef72b9fdf0270e555c11d"
-dependencies = [
- "darling 0.23.0",
- "indoc",
- "proc-macro2",
- "quote",
- "syn 2.0.117",
-]
-
 [[package]]
 name = "instant"
 version = "0.1.13"
@@ -9820,17 +9722,6 @@ dependencies = [
  "mutate_once",
 ]
 
-[[package]]
-name = "kasuari"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fe90c1150662e858c7d5f945089b7517b0a80d8bf7ba4b1b5ffc984e7230a5b"
-dependencies = [
- "hashbrown 0.16.1",
- "portable-atomic",
- "thiserror 2.0.18",
-]
-
 [[package]]
 name = "keyboard-types"
 version = "0.7.0"
@@ -9987,12 +9878,6 @@ dependencies = [
  "smallvec 1.15.1",
 ]
 
-[[package]]
-name = "lab"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf36173d4167ed999940f804952e6b08197cae5ad5d572eb4db150ce8ad5d58f"
-
 [[package]]
 name = "lago"
 version = "0.1.0"
@@ -10359,15 +10244,6 @@ dependencies = [
  "wayland-protocols-wlr",
 ]
 
-[[package]]
-name = "line-clipping"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f4de44e98ddbf09375cbf4d17714d18f39195f4f4894e8524501726fd9a8a4a"
-dependencies = [
- "bitflags 2.11.0",
-]
-
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@@ -10528,15 +10404,6 @@ dependencies = [
  "hashbrown 0.15.5",
 ]
 
-[[package]]
-name = "lru"
-version = "0.16.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1dc47f592c06f33f8e3aea9591776ec7c9f9e4124778ff8a3c3b87159f7e593"
-dependencies = [
- "hashbrown 0.16.1",
-]
-
 [[package]]
 name = "lru-slab"
 version = "0.1.2"
@@ -10585,16 +10452,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4"
 
-[[package]]
-name = "mac_address"
-version = "1.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0aeb26bf5e836cc1c341c8106051b573f1766dfa05aa87f0b98be5e51b02303"
-dependencies = [
- "nix 0.29.0",
- "winapi",
-]
-
 [[package]]
 name = "mac_address2"
 version = "2.0.2"
@@ -10826,12 +10683,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "memmem"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a64a92489e2744ce060c349162be1c5f33c6969234104dbd99ddb5feb08b8c15"
-
 [[package]]
 name = "memo-map"
 version = "0.3.3"
@@ -11199,19 +11050,6 @@ dependencies = [
  "memoffset",
 ]
 
-[[package]]
-name = "nix"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
-dependencies = [
- "bitflags 2.11.0",
- "cfg-if",
- "cfg_aliases 0.2.1",
- "libc",
- "memoffset",
-]
-
 [[package]]
 name = "nix"
 version = "0.30.1"
@@ -12216,15 +12054,6 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
 
-[[package]]
-name = "ordered-float"
-version = "4.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
-dependencies = [
- "num-traits",
-]
-
 [[package]]
 name = "ordered-float"
 version = "5.1.0"
@@ -12709,7 +12538,7 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3672b37090dbd86368a4145bc067582552b29c27377cad4e0a306c97f9bd7772"
 dependencies = [
- "fixedbitset 0.5.7",
+ "fixedbitset",
  "indexmap 2.13.0",
 ]
 
@@ -12719,7 +12548,7 @@ version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8701b58ea97060d5e5b155d383a69952a60943f0e6dfe30b04c287beb0b27455"
 dependencies = [
- "fixedbitset 0.5.7",
+ "fixedbitset",
  "hashbrown 0.15.5",
  "indexmap 2.13.0",
 ]
@@ -14008,91 +13837,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "ratatui"
-version = "0.30.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1ce67fb8ba4446454d1c8dbaeda0557ff5e94d39d5e5ed7f10a65eb4c8266bc"
-dependencies = [
- "instability",
- "ratatui-core",
- "ratatui-crossterm",
- "ratatui-macros",
- "ratatui-termwiz",
- "ratatui-widgets",
-]
-
-[[package]]
-name = "ratatui-core"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ef8dea09a92caaf73bff7adb70b76162e5937524058a7e5bff37869cbbec293"
-dependencies = [
- "bitflags 2.11.0",
- "compact_str",
- "hashbrown 0.16.1",
- "indoc",
- "itertools 0.14.0",
- "kasuari",
- "lru 0.16.3",
- "strum 0.27.2",
- "thiserror 2.0.18",
- "unicode-segmentation",
- "unicode-truncate",
- "unicode-width 0.2.2",
-]
-
-[[package]]
-name = "ratatui-crossterm"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "577c9b9f652b4c121fb25c6a391dd06406d3b092ba68827e6d2f09550edc54b3"
-dependencies = [
- "cfg-if",
- "crossterm",
- "instability",
- "ratatui-core",
-]
-
-[[package]]
-name = "ratatui-macros"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7f1342a13e83e4bb9d0b793d0ea762be633f9582048c892ae9041ef39c936f4"
-dependencies = [
- "ratatui-core",
- "ratatui-widgets",
-]
-
-[[package]]
-name = "ratatui-termwiz"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f76fe0bd0ed4295f0321b1676732e2454024c15a35d01904ddb315afd3d545c"
-dependencies = [
- "ratatui-core",
- "termwiz",
-]
-
-[[package]]
-name = "ratatui-widgets"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7dbfa023cd4e604c2553483820c5fe8aa9d71a42eea5aa77c6e7f35756612db"
-dependencies = [
- "bitflags 2.11.0",
- "hashbrown 0.16.1",
- "indoc",
- "instability",
- "itertools 0.14.0",
- "line-clipping",
- "ratatui-core",
- "strum 0.27.2",
- "time",
- "unicode-segmentation",
- "unicode-width 0.2.2",
-]
-
 [[package]]
 name = "rav1e"
 version = "0.8.1"
@@ -16028,17 +15772,6 @@ dependencies = [
  "signal-hook-registry",
 ]
 
-[[package]]
-name = "signal-hook-mio"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
-dependencies = [
- "libc",
- "mio",
- "signal-hook",
-]
-
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.8"
@@ -17459,7 +17192,7 @@ dependencies = [
  "itertools 0.14.0",
  "levenshtein_automata",
  "log",
- "lru 0.12.5",
+ "lru",
  "lz4_flex",
  "measure_time",
  "memmap2",
@@ -18338,7 +18071,7 @@ dependencies = [
  "intercept",
  "language",
  "mac 0.1.0",
- "ordered-float 5.1.0",
+ "ordered-float",
  "owhisper-client",
  "owhisper-interface",
  "quickcheck",
@@ -18365,6 +18098,7 @@ dependencies = [
  "tokio-stream",
  "tokio-util",
  "tracing",
+ "transcript",
  "url",
  "uuid",
  "vad-ext",
@@ -18395,6 +18129,7 @@ dependencies = [
  "tokio",
  "tokio-stream",
  "tracing",
+ "transcript",
 ]
 
 [[package]]
@@ -19340,75 +19075,12 @@ dependencies = [
  "unicode-segmentation",
 ]
 
-[[package]]
-name = "terminfo"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4ea810f0692f9f51b382fff5893887bb4580f5fa246fde546e0b13e7fcee662"
-dependencies = [
- "fnv",
- "nom 7.1.3",
- "phf 0.11.3",
- "phf_codegen 0.11.3",
-]
-
-[[package]]
-name = "termios"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "411c5bf740737c7918b8b1fe232dca4dc9f8e754b8ad5e20966814001ed0ac6b"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "termtree"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
 
-[[package]]
-name = "termwiz"
-version = "0.23.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4676b37242ccbd1aabf56edb093a4827dc49086c0ffd764a5705899e0f35f8f7"
-dependencies = [
- "anyhow",
- "base64 0.22.1",
- "bitflags 2.11.0",
- "fancy-regex 0.11.0",
- "filedescriptor",
- "finl_unicode",
- "fixedbitset 0.4.2",
- "hex",
- "lazy_static",
- "libc",
- "log",
- "memmem",
- "nix 0.29.0",
- "num-derive",
- "num-traits",
- "ordered-float 4.6.0",
- "pest",
- "pest_derive",
- "phf 0.11.3",
- "sha2",
- "signal-hook",
- "siphasher 1.0.2",
- "terminfo",
- "termios",
- "thiserror 1.0.69",
- "ucd-trie",
- "unicode-segmentation",
- "vtparse",
- "wezterm-bidi",
- "wezterm-blob-leases",
- "wezterm-color-types",
- "wezterm-dynamic",
- "wezterm-input-types",
- "winapi",
-]
-
 [[package]]
 name = "testcontainers"
 version = "0.24.0"
@@ -20351,26 +20023,9 @@ dependencies = [
 name = "transcript"
 version = "0.1.0"
 dependencies = [
- "audio",
- "audio-utils",
- "axum 0.8.8",
- "bytes",
- "clap",
- "crossterm",
- "data",
- "futures-util",
- "libc",
- "owhisper-client",
  "owhisper-interface",
- "ratatui",
  "serde",
- "serde_json",
  "specta",
- "strum 0.27.2",
- "tokio",
- "tokio-stream",
- "tower 0.5.3",
- "transcribe-cactus",
  "uuid",
 ]
 
@@ -21120,17 +20775,6 @@ version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
-[[package]]
-name = "unicode-truncate"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b380a1238663e5f8a691f9039c73e1cdae598a30e9855f541d29b08b53e9a5"
-dependencies = [
- "itertools 0.14.0",
- "unicode-segmentation",
- "unicode-width 0.2.2",
-]
-
 [[package]]
 name = "unicode-vo"
 version = "0.1.0"
@@ -21327,7 +20971,6 @@ version = "1.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
 dependencies = [
- "atomic",
  "getrandom 0.4.1",
  "js-sys",
  "serde_core",
@@ -21532,15 +21175,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "vtparse"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d9b2acfb050df409c972a37d3b8e08cdea3bddb0c09db9d53137e504cfabed0"
-dependencies = [
- "utf8parse",
-]
-
 [[package]]
 name = "walkdir"
 version = "2.5.0"
@@ -22043,78 +21677,6 @@ version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a28ac98ddc8b9274cb41bb4d9d4d5c425b6020c50c46f25559911905610b4a88"
 
-[[package]]
-name = "wezterm-bidi"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c0a6e355560527dd2d1cf7890652f4f09bb3433b6aadade4c9b5ed76de5f3ec"
-dependencies = [
- "log",
- "wezterm-dynamic",
-]
-
-[[package]]
-name = "wezterm-blob-leases"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "692daff6d93d94e29e4114544ef6d5c942a7ed998b37abdc19b17136ea428eb7"
-dependencies = [
- "getrandom 0.3.4",
- "mac_address",
- "sha2",
- "thiserror 1.0.69",
- "uuid",
-]
-
-[[package]]
-name = "wezterm-color-types"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7de81ef35c9010270d63772bebef2f2d6d1f2d20a983d27505ac850b8c4b4296"
-dependencies = [
- "csscolorparser",
- "deltae",
- "lazy_static",
- "wezterm-dynamic",
-]
-
-[[package]]
-name = "wezterm-dynamic"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f2ab60e120fd6eaa68d9567f3226e876684639d22a4219b313ff69ec0ccd5ac"
-dependencies = [
- "log",
- "ordered-float 4.6.0",
- "strsim",
- "thiserror 1.0.69",
- "wezterm-dynamic-derive",
-]
-
-[[package]]
-name = "wezterm-dynamic-derive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c0cf2d539c645b448eaffec9ec494b8b19bd5077d9e58cb1ae7efece8d575b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "wezterm-input-types"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7012add459f951456ec9d6c7e6fc340b1ce15d6fc9629f8c42853412c029e57e"
-dependencies = [
- "bitflags 1.3.2",
- "euclid",
- "lazy_static",
- "serde",
- "wezterm-dynamic",
-]
-
 [[package]]
 name = "which"
 version = "4.4.2"
diff --git a/crates/transcript/Cargo.toml b/crates/transcript/Cargo.toml
index 0e530cb862..d4462370cc 100644
--- a/crates/transcript/Cargo.toml
+++ b/crates/transcript/Cargo.toml
@@ -3,28 +3,6 @@ name = "transcript"
 version = "0.1.0"
 edition = "2024"
 
-[dev-dependencies]
-hypr-data = { workspace = true }
-libc = "0.2"
-
-serde_json = { workspace = true }
-strum = { workspace = true, features = ["derive"] }
-
-clap = { workspace = true, features = ["derive", "env"] }
-crossterm = "0.29"
-ratatui = { version = "0.30", features = ["crossterm_0_29"] }
-
-axum = { workspace = true }
-bytes = { workspace = true }
-futures-util = { workspace = true }
-hypr-audio = { workspace = true }
-hypr-audio-utils = { workspace = true }
-hypr-transcribe-cactus = { workspace = true }
-owhisper-client = { workspace = true }
-tokio = { workspace = true, features = ["rt", "macros", "sync", "net"] }
-tokio-stream = { workspace = true }
-tower = { workspace = true }
-
 [dependencies]
 owhisper-interface = { workspace = true }
 
diff --git a/crates/transcript/examples/cli/app.rs b/crates/transcript/examples/cli/app.rs
deleted file mode 100644
index c91081868b..0000000000
--- a/crates/transcript/examples/cli/app.rs
+++ /dev/null
@@ -1,282 +0,0 @@
-use crossterm::event::{KeyCode, MouseButton, MouseEvent, MouseEventKind};
-use owhisper_interface::stream::StreamResponse;
-use ratatui::style::Style;
-use transcript::SequentialIdGen;
-use transcript::input::TranscriptInput;
-use transcript::postprocess::PostProcessUpdate;
-use transcript::types::{PartialWord, SpeakerHint, TranscriptWord};
-use transcript::view::{ProcessOutcome, TranscriptView};
-
-use crate::feed::TranscriptFeed;
-use crate::logger::LogBuffer;
-use crate::renderer::debug::DebugSection;
-use crate::renderer::{LayoutInfo, WordRegion};
-use crate::viewport::ViewportState;
-
-fn lookup_word(region: &WordRegion, view: &TranscriptView) -> Option<SelectedWord> {
-    let frame = view.frame();
-    let dbg = view.pipeline_debug();
-    if region.is_final {
-        let word = frame.final_words.get(region.index)?.clone();
-        let speaker = frame
-            .speaker_hints
-            .iter()
-            .find(|h| h.word_id == word.id)
-            .cloned();
-        Some(SelectedWord::Final { word, speaker })
-    } else {
-        let word = frame.partial_words.get(region.index)?.clone();
-        let stability = dbg
-            .partial_stability
-            .iter()
-            .find(|(text, _)| *text == word.text)
-            .map(|(_, count)| *count);
-        Some(SelectedWord::Partial { word, stability })
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub enum LastEvent {
-    Final,
-    Partial,
-    Correction,
-    Skipped,
-}
-
-pub enum KeyAction {
-    Quit,
-    Continue { reset_tick: bool },
-}
-
-pub enum SelectedWord {
-    Final {
-        word: TranscriptWord,
-        speaker: Option<SpeakerHint>,
-    },
-    Partial {
-        word: PartialWord,
-        stability: Option<u32>,
-    },
-}
-
-pub struct App {
-    source: Box<dyn TranscriptFeed>,
-    source_debug: Vec<DebugSection>,
-    pub position: usize,
-    pub paused: bool,
-    pub speed_ms: u64,
-    pub view: TranscriptView,
-    pub source_name: String,
-    pub last_event: LastEvent,
-    pub last_postprocess: Option<PostProcessUpdate>,
-    pub viewport: ViewportState,
-    pub selected_word: Option<SelectedWord>,
-    pub log_buffer: LogBuffer,
-}
-
-impl App {
-    pub fn new(
-        source: Box<dyn TranscriptFeed>,
-        source_debug: Vec<DebugSection>,
-        speed_ms: u64,
-        source_name: String,
-        log_buffer: LogBuffer,
-    ) -> Self {
-        let paused = !source.is_live();
-        Self {
-            source,
-            source_debug,
-            position: 0,
-            paused,
-            speed_ms,
-            view: TranscriptView::with_config(SequentialIdGen::new()),
-            source_name,
-            last_event: LastEvent::Skipped,
-            last_postprocess: None,
-            viewport: ViewportState::new(),
-            selected_word: None,
-            log_buffer,
-        }
-    }
-
-    pub fn source_debug_sections(&self) -> Vec<DebugSection> {
-        let mut sections = self.source_debug.clone();
-        sections.extend(self.source.debug_sections());
-        sections
-    }
-
-    pub fn source_word_style(&self, channel: i32, start_ms: i64, end_ms: i64) -> Option<Style> {
-        self.source.word_style(channel, start_ms, end_ms)
-    }
-
-    pub fn total(&self) -> usize {
-        self.source.total()
-    }
-
-    pub fn is_live(&self) -> bool {
-        self.source.is_live()
-    }
-
-    pub fn is_done(&self) -> bool {
-        if self.source.is_live() {
-            return false;
-        }
-        self.position >= self.total()
-    }
-
-    pub fn advance(&mut self) -> bool {
-        if self.source.is_live() {
-            if let Some(sr) = self.source.poll_next().cloned() {
-                self.position = self.source.total();
-                self.process_one(&sr);
-                return true;
-            }
-            return false;
-        }
-
-        if self.position >= self.total() {
-            return false;
-        }
-        if let Some(sr) = self.source.get(self.position).cloned() {
-            self.process_one(&sr);
-        }
-        self.position += 1;
-        true
-    }
-
-    pub fn handle_key(&mut self, code: KeyCode) -> KeyAction {
-        match code {
-            KeyCode::Char('q') => return KeyAction::Quit,
-            KeyCode::Esc if self.selected_word.is_some() => {
-                self.selected_word = None;
-            }
-            KeyCode::Esc => return KeyAction::Quit,
-            KeyCode::Char(' ') => {
-                self.paused = !self.paused;
-                if !self.paused {
-                    self.viewport.auto_scroll = true;
-                }
-                return KeyAction::Continue { reset_tick: true };
-            }
-            KeyCode::Right if !self.source.is_live() => {
-                self.seek_to(self.position + 1);
-            }
-            KeyCode::Left if !self.source.is_live() => {
-                self.seek_to(self.position.saturating_sub(1));
-            }
-            KeyCode::Up => {
-                self.speed_ms = self.speed_ms.saturating_sub(10).max(5);
-            }
-            KeyCode::Down => {
-                self.speed_ms += 10;
-            }
-            KeyCode::Home if !self.source.is_live() => {
-                self.seek_to(0);
-            }
-            KeyCode::End if !self.source.is_live() => {
-                let total = self.total();
-                self.seek_to(total);
-                self.view.flush();
-                self.viewport.auto_scroll = true;
-            }
-            KeyCode::PageUp => {
-                self.viewport.scroll_up(5);
-            }
-            KeyCode::PageDown => {
-                self.viewport.scroll_down(5);
-            }
-            KeyCode::Char('p') => {
-                self.simulate_postprocess();
-            }
-            _ => {}
-        }
-        KeyAction::Continue { reset_tick: false }
-    }
-
-    pub fn update_layout(&mut self, layout: LayoutInfo) {
-        self.viewport.update(layout);
-    }
-
-    pub fn handle_mouse(&mut self, event: MouseEvent) {
-        if event.kind != MouseEventKind::Down(MouseButton::Left) {
-            return;
-        }
-
-        let area = self.viewport.area;
-        let col = event.column;
-        let row = event.row;
-        if col < area.x || col >= area.x + area.width || row < area.y || row >= area.y + area.height
-        {
-            return;
-        }
-
-        let scroll_offset = self.viewport.current_scroll_offset();
-        let logical_col = col - area.x;
-        let logical_row = (row - area.y) + scroll_offset;
-
-        let hit = self.viewport.word_regions.iter().find(|r| {
-            r.row == logical_row && logical_col >= r.col_start && logical_col < r.col_end
-        });
-
-        if let Some(region) = hit {
-            self.selected_word = lookup_word(region, &self.view);
-        }
-    }
-
-    fn process_one(&mut self, sr: &StreamResponse) {
-        match TranscriptInput::from_stream_response(sr) {
-            Some(input) => {
-                self.last_event = match &input {
-                    TranscriptInput::Final { .. } => LastEvent::Final,
-                    TranscriptInput::Partial { .. } => LastEvent::Partial,
-                    TranscriptInput::Correction { .. } => LastEvent::Correction,
-                };
-                if let ProcessOutcome::Corrected(update) = self.view.process(input) {
-                    self.last_postprocess = Some(update);
-                }
-            }
-            None => {
-                self.last_event = LastEvent::Skipped;
-            }
-        }
-    }
-
-    fn seek_to(&mut self, target: usize) {
-        let target = target.min(self.total());
-        self.view = TranscriptView::with_config(SequentialIdGen::new());
-        self.last_postprocess = None;
-        self.selected_word = None;
-        self.viewport.reset();
-        self.position = 0;
-        for i in 0..target {
-            if let Some(sr) = self.source.get(i).cloned() {
-                self.process_one(&sr);
-            }
-        }
-        self.position = target;
-    }
-
-    fn simulate_postprocess(&mut self) {
-        let finals = self.view.frame().final_words;
-        if finals.is_empty() {
-            return;
-        }
-        let title_case = |s: &str| -> String {
-            let trimmed = s.trim_start_matches(' ');
-            let leading = &s[..s.len() - trimmed.len()];
-            let mut chars = trimmed.chars();
-            match chars.next() {
-                None => s.to_string(),
-                Some(first) => format!("{leading}{}{}", first.to_uppercase(), chars.as_str()),
-            }
-        };
-        let transformed = finals
-            .into_iter()
-            .map(|w| TranscriptWord {
-                text: title_case(&w.text),
-                ..w
-            })
-            .collect();
-        self.last_postprocess = Some(self.view.apply_postprocess(transformed));
-    }
-}
diff --git a/crates/transcript/examples/cli/feed.rs b/crates/transcript/examples/cli/feed.rs
deleted file mode 100644
index 82106cee3c..0000000000
--- a/crates/transcript/examples/cli/feed.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use owhisper_interface::stream::StreamResponse;
-use ratatui::style::Style;
-
-use crate::renderer::debug::DebugSection;
-
-pub trait TranscriptFeed {
-    fn total(&self) -> usize;
-    fn get(&self, index: usize) -> Option<&StreamResponse>;
-    fn poll_next(&mut self) -> Option<&StreamResponse>;
-    fn is_live(&self) -> bool;
-
-    fn debug_sections(&self) -> Vec<DebugSection> {
-        vec![]
-    }
-
-    fn word_style(&self, channel: i32, start_ms: i64, end_ms: i64) -> Option<Style> {
-        let _ = (channel, start_ms, end_ms);
-        None
-    }
-}
-
-pub struct LiveCollector {
-    rx: std::sync::mpsc::Receiver<StreamResponse>,
-    collected: Vec<StreamResponse>,
-}
-
-impl LiveCollector {
-    pub fn new(rx: std::sync::mpsc::Receiver<StreamResponse>) -> Self {
-        Self {
-            rx,
-            collected: Vec::new(),
-        }
-    }
-
-    pub fn total(&self) -> usize {
-        self.collected.len()
-    }
-
-    pub fn get(&self, index: usize) -> Option<&StreamResponse> {
-        self.collected.get(index)
-    }
-
-    pub fn poll_next(&mut self) -> Option<&StreamResponse> {
-        if let Ok(sr) = self.rx.try_recv() {
-            self.collected.push(sr);
-            self.collected.last()
-        } else {
-            None
-        }
-    }
-
-    pub fn try_recv(&self) -> Option<StreamResponse> {
-        self.rx.try_recv().ok()
-    }
-
-    pub fn push(&mut self, sr: StreamResponse) {
-        self.collected.push(sr);
-    }
-
-    pub fn last(&self) -> Option<&StreamResponse> {
-        self.collected.last()
-    }
-}
diff --git a/crates/transcript/examples/cli/fixture.rs b/crates/transcript/examples/cli/fixture.rs
deleted file mode 100644
index 3e114fb6a4..0000000000
--- a/crates/transcript/examples/cli/fixture.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-#[derive(Clone, clap::ValueEnum, strum::Display)]
-#[strum(serialize_all = "kebab-case")]
-pub enum Fixture {
-    #[strum(serialize = "deepgram-english")]
-    #[value(name = "deepgram-english")]
-    Deepgram,
-    #[strum(serialize = "soniox-english")]
-    #[value(name = "soniox-english")]
-    Soniox,
-    #[strum(serialize = "soniox-korean")]
-    #[value(name = "soniox-korean")]
-    SonioxKorean,
-}
-
-impl Fixture {
-    pub fn json(&self) -> &'static str {
-        match self {
-            Self::Deepgram => hypr_data::english_1::DEEPGRAM_JSON,
-            Self::Soniox => hypr_data::english_1::SONIOX_JSON,
-            Self::SonioxKorean => hypr_data::korean_1::SONIOX_JSON,
-        }
-    }
-}
diff --git a/crates/transcript/examples/cli/logger.rs b/crates/transcript/examples/cli/logger.rs
deleted file mode 100644
index b97157f98c..0000000000
--- a/crates/transcript/examples/cli/logger.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use std::collections::VecDeque;
-use std::io::{BufRead, BufReader};
-use std::os::fd::FromRawFd;
-use std::sync::{Arc, Mutex};
-
-pub type LogBuffer = Arc<Mutex<VecDeque<String>>>;
-
-const MAX_LINES: usize = 20;
-
-pub fn setup() -> LogBuffer {
-    let buffer: LogBuffer = Arc::new(Mutex::new(VecDeque::with_capacity(MAX_LINES)));
-    let buffer_clone = buffer.clone();
-
-    let mut pipe_fds = [-1i32; 2];
-    // SAFETY: pipe(2) is safe to call; fds are valid for the lifetime of the process.
-    unsafe {
-        libc::pipe(pipe_fds.as_mut_ptr());
-        libc::dup2(pipe_fds[1], libc::STDERR_FILENO);
-        libc::close(pipe_fds[1]);
-    }
-
-    std::thread::Builder::new()
-        .name("stderr-reader".into())
-        .spawn(move || {
-            let file = unsafe { std::fs::File::from_raw_fd(pipe_fds[0]) };
-            let reader = BufReader::new(file);
-            for line in reader.lines().map_while(Result::ok) {
-                if line.is_empty() {
-                    continue;
-                }
-                let mut buf = buffer_clone.lock().unwrap();
-                if buf.len() >= MAX_LINES {
-                    buf.pop_front();
-                }
-                buf.push_back(line);
-            }
-        })
-        .expect("failed to spawn stderr-reader thread");
-
-    buffer
-}
diff --git a/crates/transcript/examples/cli/main.rs b/crates/transcript/examples/cli/main.rs
deleted file mode 100644
index f6318fb4ca..0000000000
--- a/crates/transcript/examples/cli/main.rs
+++ /dev/null
@@ -1,231 +0,0 @@
-mod app;
-mod feed;
-mod fixture;
-mod logger;
-mod provider;
-mod renderer;
-mod source;
-mod theme;
-mod viewport;
-
-use std::time::{Duration, Instant};
-
-use app::{App, KeyAction};
-use crossterm::event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyEventKind};
-use crossterm::execute;
-use feed::TranscriptFeed;
-use fixture::Fixture;
-use owhisper_client::Provider;
-use provider::{CactusProvider, CloudProvider};
-use ratatui::DefaultTerminal;
-use renderer::debug::DebugSection;
-use source::FixtureSource;
-
-#[derive(clap::Parser)]
-#[command(name = "replay", about = "Replay transcript fixture in the terminal")]
-struct Args {
-    #[arg(short, long, default_value_t = 30)]
-    speed: u64,
-
-    #[command(subcommand)]
-    source: SourceCmd,
-}
-
-#[derive(clap::Subcommand)]
-enum SourceCmd {
-    /// Replay a built-in transcript fixture
-    Fixture {
-        #[arg(default_value_t = Fixture::Deepgram)]
-        name: Fixture,
-    },
-    /// Stream an audio file for live transcription
-    File {
-        path: String,
-        #[command(subcommand)]
-        provider: ProviderCmd,
-    },
-    /// Stream default microphone for live transcription
-    Mic {
-        #[command(subcommand)]
-        provider: ProviderCmd,
-    },
-}
-
-#[derive(clap::Subcommand)]
-enum ProviderCmd {
-    /// Transcribe locally using a Cactus model
-    Cactus {
-        #[arg(long)]
-        model: String,
-    },
-    /// Transcribe via a cloud STT provider
-    Cloud {
-        #[arg(long)]
-        provider: Provider,
-        /// API key (falls back to the provider's env var if omitted)
-        #[arg(long)]
-        api_key: Option<String>,
-    },
-}
-
-fn main() {
-    use clap::Parser;
-    let args = Args::parse();
-    let speed_ms = args.speed;
-
-    let (replay_source, source_debug, source_name): (
-        Box<dyn TranscriptFeed>,
-        Vec<DebugSection>,
-        String,
-    ) = match args.source {
-        SourceCmd::Fixture { name } => {
-            let label = name.to_string();
-            (
-                Box::new(FixtureSource::from_json(label.clone(), name.json())),
-                vec![],
-                label,
-            )
-        }
-        SourceCmd::File { path, provider } => {
-            let label = format!("file:{path}");
-            let path_for_closure = path.clone();
-            let feed: Box<dyn TranscriptFeed> = match provider {
-                ProviderCmd::Cactus { model } => {
-                    Box::new(CactusProvider::spawn(&model, move || {
-                        let s = hypr_audio_utils::source_from_path(&path_for_closure)
-                            .expect("failed to open audio file");
-                        source::throttled_audio_stream(s)
-                    }))
-                }
-                ProviderCmd::Cloud { provider, api_key } => {
-                    Box::new(CloudProvider::spawn(provider, api_key, move || {
-                        let s = hypr_audio_utils::source_from_path(&path_for_closure)
-                            .expect("failed to open audio file");
-                        source::throttled_audio_stream(s)
-                    }))
-                }
-            };
-            let debug = vec![DebugSection {
-                title: "file",
-                entries: vec![("path", path)],
-            }];
-            (feed, debug, label)
-        }
-        SourceCmd::Mic { provider } => {
-            use hypr_audio::MicInput;
-
-            let mic = MicInput::new(None).expect("failed to open microphone");
-            let device_name = mic.device_name();
-            let label = format!("mic:{device_name}");
-
-            let feed: Box<dyn TranscriptFeed> = match provider {
-                ProviderCmd::Cactus { model } => {
-                    Box::new(CactusProvider::spawn(&model, move || {
-                        source::throttled_audio_stream(mic.stream())
-                    }))
-                }
-                ProviderCmd::Cloud { provider, api_key } => {
-                    Box::new(CloudProvider::spawn(provider, api_key, move || {
-                        source::throttled_audio_stream(mic.stream())
-                    }))
-                }
-            };
-            let debug = vec![DebugSection {
-                title: "mic",
-                entries: vec![("device", device_name)],
-            }];
-            (feed, debug, label)
-        }
-    };
-
-    let log_buffer = logger::setup();
-
-    let mut terminal = ratatui::init();
-    execute!(std::io::stdout(), EnableMouseCapture).ok();
-    let result = run(
-        &mut terminal,
-        replay_source,
-        source_debug,
-        speed_ms,
-        source_name.clone(),
-        log_buffer,
-    );
-    execute!(std::io::stdout(), DisableMouseCapture).ok();
-    ratatui::restore();
-
-    match result {
-        Ok(app) => {
-            println!(
-                "Done. {} final words from {} events ({}).",
-                app.view.frame().final_words.len(),
-                app.total(),
-                source_name,
-            );
-        }
-        Err(e) => {
-            eprintln!("Error: {e}");
-            std::process::exit(1);
-        }
-    }
-}
-
-fn run(
-    terminal: &mut DefaultTerminal,
-    source: Box<dyn TranscriptFeed>,
-    source_debug: Vec<DebugSection>,
-    speed_ms: u64,
-    source_name: String,
-    log_buffer: logger::LogBuffer,
-) -> std::io::Result<App> {
-    let mut app = App::new(source, source_debug, speed_ms, source_name, log_buffer);
-    let mut last_tick = Instant::now();
-
-    loop {
-        let mut layout = renderer::LayoutInfo::default();
-        terminal.draw(|frame| {
-            layout = renderer::render(frame, &app);
-        })?;
-        app.update_layout(layout);
-
-        let tick_duration = Duration::from_millis(app.speed_ms);
-        let elapsed = last_tick.elapsed();
-        let timeout = tick_duration.saturating_sub(elapsed);
-
-        if event::poll(timeout)? {
-            match event::read()? {
-                Event::Key(key) => {
-                    if key.kind != KeyEventKind::Press {
-                        continue;
-                    }
-                    match app.handle_key(key.code) {
-                        KeyAction::Quit => break,
-                        KeyAction::Continue { reset_tick } => {
-                            if reset_tick {
-                                last_tick = Instant::now();
-                            }
-                        }
-                    }
-                }
-                Event::Mouse(mouse) => {
-                    app.handle_mouse(mouse);
-                }
-                _ => {}
-            }
-        } else if !app.paused {
-            if last_tick.elapsed() >= tick_duration {
-                app.advance();
-                last_tick = Instant::now();
-
-                if app.is_done() {
-                    app.view.flush();
-                    terminal.draw(|frame| {
-                        renderer::render(frame, &app);
-                    })?;
-                    app.paused = true;
-                }
-            }
-        }
-    }
-
-    Ok(app)
-}
diff --git a/crates/transcript/examples/cli/provider/cactus.rs b/crates/transcript/examples/cli/provider/cactus.rs
deleted file mode 100644
index f21319b5bf..0000000000
--- a/crates/transcript/examples/cli/provider/cactus.rs
+++ /dev/null
@@ -1,258 +0,0 @@
-use std::collections::HashMap;
-
-use futures_util::{Stream, StreamExt};
-use owhisper_interface::stream::StreamResponse;
-use owhisper_interface::{ControlMessage, MixedMessage};
-use ratatui::style::Style;
-
-use crate::feed::{LiveCollector, TranscriptFeed};
-use crate::renderer::debug::DebugSection;
-use crate::theme::THEME;
-
-#[derive(Clone, Default)]
-struct CactusMetrics {
-    decode_tps: f64,
-    prefill_tps: f64,
-    time_to_first_token_ms: f64,
-    total_time_ms: f64,
-}
-
-impl CactusMetrics {
-    fn from_stream_response(sr: &StreamResponse) -> Option<Self> {
-        let extra = match sr {
-            StreamResponse::TranscriptResponse { metadata, .. } => metadata.extra.as_ref()?,
-            _ => return None,
-        };
-        let f = |key: &str| -> f64 { extra.get(key).and_then(|v| v.as_f64()).unwrap_or(0.0) };
-        Some(Self {
-            decode_tps: f("decode_tps"),
-            prefill_tps: f("prefill_tps"),
-            time_to_first_token_ms: f("time_to_first_token_ms"),
-            total_time_ms: f("total_time_ms"),
-        })
-    }
-}
-
-struct PendingHandoff {
-    channel: i32,
-    start_ms: i64,
-    end_ms: i64,
-}
-
-pub struct CactusProvider {
-    collector: LiveCollector,
-    metrics: Option<CactusMetrics>,
-    pending_handoffs: HashMap<u64, PendingHandoff>,
-}
-
-impl CactusProvider {
-    pub fn spawn<F, S>(model: &str, make_stream: F) -> Self
-    where
-        F: FnOnce() -> S + Send + 'static,
-        S: Stream<Item = MixedMessage<bytes::Bytes, ControlMessage>> + Send + Unpin + 'static,
-    {
-        let api_base = spawn_local_stt_server(model);
-        Self {
-            collector: LiveCollector::new(spawn_cactus_session(api_base, make_stream)),
-            metrics: None,
-            pending_handoffs: HashMap::new(),
-        }
-    }
-}
-
-impl TranscriptFeed for CactusProvider {
-    fn total(&self) -> usize {
-        self.collector.total()
-    }
-
-    fn get(&self, index: usize) -> Option<&StreamResponse> {
-        self.collector.get(index)
-    }
-
-    fn poll_next(&mut self) -> Option<&StreamResponse> {
-        let sr = self.collector.try_recv()?;
-        if let Some(m) = CactusMetrics::from_stream_response(&sr) {
-            self.metrics = Some(m);
-        }
-        update_pending_handoffs(&sr, &mut self.pending_handoffs);
-        self.collector.push(sr);
-        self.collector.last()
-    }
-
-    fn is_live(&self) -> bool {
-        true
-    }
-
-    fn word_style(&self, channel: i32, start_ms: i64, end_ms: i64) -> Option<Style> {
-        let overlaps = self
-            .pending_handoffs
-            .values()
-            .any(|h| h.channel == channel && h.start_ms < end_ms && h.end_ms > start_ms);
-        overlaps.then_some(THEME.transcript_pending_correction)
-    }
-
-    fn debug_sections(&self) -> Vec<DebugSection> {
-        let Some(m) = &self.metrics else {
-            return vec![];
-        };
-        vec![DebugSection {
-            title: "cactus",
-            entries: vec![
-                ("decode", format!("{:.0} tok/s", m.decode_tps)),
-                ("prefill", format!("{:.0} tok/s", m.prefill_tps)),
-                ("ttft", format!("{:.0}ms", m.time_to_first_token_ms)),
-                ("total", format!("{:.0}ms", m.total_time_ms)),
-            ],
-        }]
-    }
-}
-
-fn update_pending_handoffs(sr: &StreamResponse, pending: &mut HashMap<u64, PendingHandoff>) {
-    let (channel, channel_index, metadata) = match sr {
-        StreamResponse::TranscriptResponse {
-            channel,
-            channel_index,
-            metadata,
-            ..
-        } => (channel, channel_index, metadata),
-        _ => return,
-    };
-
-    let extra = match &metadata.extra {
-        Some(e) => e,
-        None => return,
-    };
-
-    let get_bool =
-        |key: &str| -> bool { extra.get(key).and_then(|v| v.as_bool()).unwrap_or(false) };
-    let get_u64 = |key: &str| -> u64 { extra.get(key).and_then(|v| v.as_u64()).unwrap_or(0) };
-
-    let ch = channel_index.first().copied().unwrap_or(0);
-
-    if get_bool("cloud_corrected") {
-        let job_id = get_u64("cloud_job_id");
-        if job_id != 0 {
-            pending.remove(&job_id);
-        }
-        return;
-    }
-
-    if get_bool("cloud_handoff") {
-        let job_id = get_u64("cloud_job_id");
-        if job_id == 0 {
-            return;
-        }
-        if let Some(alt) = channel.alternatives.first() {
-            let words = &alt.words;
-            if !words.is_empty() {
-                let start_ms = (words.first().map(|w| w.start).unwrap_or(0.0) * 1000.0) as i64;
-                let end_ms = (words.last().map(|w| w.end).unwrap_or(0.0) * 1000.0) as i64;
-                pending.insert(
-                    job_id,
-                    PendingHandoff {
-                        channel: ch,
-                        start_ms,
-                        end_ms,
-                    },
-                );
-            }
-        }
-    }
-}
-
-fn spawn_local_stt_server(model_path: &str) -> String {
-    use axum::error_handling::HandleError;
-    use axum::{Router, http::StatusCode};
-    use hypr_transcribe_cactus::{CactusConfig, TranscribeService};
-
-    let model_path = model_path.to_string();
-
-    let (tx, rx) = std::sync::mpsc::channel();
-
-    std::thread::spawn(move || {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("tokio runtime");
-
-        rt.block_on(async move {
-            let service = TranscribeService::builder()
-                .model_path(model_path.into())
-                .cactus_config(CactusConfig::default())
-                .build();
-
-            let app = Router::new().route_service(
-                "/v1/listen",
-                HandleError::new(service, |e: String| async move {
-                    (StatusCode::INTERNAL_SERVER_ERROR, e)
-                }),
-            );
-
-            let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
-                .await
-                .expect("failed to bind STT server");
-            let addr = listener.local_addr().expect("failed to get local addr");
-            tx.send(format!("http://{}/v1", addr))
-                .expect("channel send");
-            axum::serve(listener, app).await.expect("STT server error");
-        });
-    });
-
-    rx.recv().expect("STT server failed to start")
-}
-
-fn spawn_cactus_session<F, S>(
-    api_base: String,
-    make_stream: F,
-) -> std::sync::mpsc::Receiver<StreamResponse>
-where
-    F: FnOnce() -> S + Send + 'static,
-    S: Stream<Item = MixedMessage<bytes::Bytes, ControlMessage>> + Send + Unpin + 'static,
-{
-    use owhisper_client::{CactusAdapter, FinalizeHandle, ListenClient};
-
-    let (tx, rx) = std::sync::mpsc::channel();
-
-    std::thread::spawn(move || {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("tokio runtime");
-
-        rt.block_on(async {
-            let client = ListenClient::builder()
-                .adapter::<CactusAdapter>()
-                .api_base(&api_base)
-                .params(owhisper_interface::ListenParams::default())
-                .build_single()
-                .await;
-
-            let audio_stream = make_stream();
-
-            let (response_stream, handle) = client
-                .from_realtime_audio(audio_stream)
-                .await
-                .expect("failed to connect to cactus");
-
-            futures_util::pin_mut!(response_stream);
-
-            while let Some(result) = response_stream.next().await {
-                match result {
-                    Ok(sr) => {
-                        if tx.send(sr).is_err() {
-                            break;
-                        }
-                    }
-                    Err(e) => {
-                        eprintln!("cactus stream error: {e}");
-                        break;
-                    }
-                }
-            }
-
-            handle.finalize().await;
-        });
-    });
-
-    rx
-}
diff --git a/crates/transcript/examples/cli/provider/cloud.rs b/crates/transcript/examples/cli/provider/cloud.rs
deleted file mode 100644
index f33cf5189e..0000000000
--- a/crates/transcript/examples/cli/provider/cloud.rs
+++ /dev/null
@@ -1,156 +0,0 @@
-use futures_util::{Stream, StreamExt};
-use owhisper_client::{
-    AssemblyAIAdapter, DashScopeAdapter, DeepgramAdapter, ElevenLabsAdapter, FinalizeHandle,
-    FireworksAdapter, GladiaAdapter, ListenClient, MistralAdapter, OpenAIAdapter, Provider,
-    RealtimeSttAdapter, SonioxAdapter,
-};
-use owhisper_interface::stream::StreamResponse;
-use owhisper_interface::{ControlMessage, ListenParams, MixedMessage};
-
-use crate::feed::{LiveCollector, TranscriptFeed};
-use crate::renderer::debug::DebugSection;
-
-pub struct CloudProvider {
-    collector: LiveCollector,
-    provider: Provider,
-}
-
-impl CloudProvider {
-    pub fn spawn<F, S>(provider: Provider, api_key: Option<String>, make_stream: F) -> Self
-    where
-        F: FnOnce() -> S + Send + 'static,
-        S: Stream<Item = MixedMessage<bytes::Bytes, ControlMessage>> + Send + Unpin + 'static,
-    {
-        Self {
-            collector: LiveCollector::new(dispatch(provider, api_key, make_stream)),
-            provider,
-        }
-    }
-}
-
-impl TranscriptFeed for CloudProvider {
-    fn total(&self) -> usize {
-        self.collector.total()
-    }
-
-    fn get(&self, index: usize) -> Option<&StreamResponse> {
-        self.collector.get(index)
-    }
-
-    fn poll_next(&mut self) -> Option<&StreamResponse> {
-        self.collector.poll_next()
-    }
-
-    fn is_live(&self) -> bool {
-        true
-    }
-
-    fn debug_sections(&self) -> Vec<DebugSection> {
-        vec![DebugSection {
-            title: "cloud",
-            entries: vec![("provider", self.provider.to_string())],
-        }]
-    }
-}
-
-fn spawn_session<A, F, S>(
-    api_base: String,
-    api_key: Option<String>,
-    make_stream: F,
-) -> std::sync::mpsc::Receiver<StreamResponse>
-where
-    A: RealtimeSttAdapter,
-    F: FnOnce() -> S + Send + 'static,
-    S: Stream<Item = MixedMessage<bytes::Bytes, ControlMessage>> + Send + Unpin + 'static,
-{
-    let (tx, rx) = std::sync::mpsc::channel();
-
-    std::thread::spawn(move || {
-        let rt = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .expect("tokio runtime");
-
-        rt.block_on(async {
-            let mut builder = ListenClient::builder()
-                .adapter::<A>()
-                .api_base(&api_base)
-                .params(ListenParams::default());
-
-            if let Some(key) = &api_key {
-                builder = builder.api_key(key);
-            }
-
-            let client = builder.build_single().await;
-            let audio_stream = make_stream();
-
-            let (response_stream, handle) = client
-                .from_realtime_audio(audio_stream)
-                .await
-                .expect("failed to connect to cloud provider");
-
-            futures_util::pin_mut!(response_stream);
-
-            while let Some(result) = response_stream.next().await {
-                match result {
-                    Ok(sr) => {
-                        if tx.send(sr).is_err() {
-                            break;
-                        }
-                    }
-                    Err(e) => {
-                        eprintln!("cloud stream error: {e}");
-                        break;
-                    }
-                }
-            }
-
-            handle.finalize().await;
-        });
-    });
-
-    rx
-}
-
-fn dispatch<F, S>(
-    provider: Provider,
-    api_key: Option<String>,
-    make_stream: F,
-) -> std::sync::mpsc::Receiver<StreamResponse>
-where
-    F: FnOnce() -> S + Send + 'static,
-    S: Stream<Item = MixedMessage<bytes::Bytes, ControlMessage>> + Send + Unpin + 'static,
-{
-    let api_base = provider.default_api_base().to_string();
-    let resolved_key = api_key.or_else(|| std::env::var(provider.env_key_name()).ok());
-
-    match provider {
-        Provider::Deepgram => {
-            spawn_session::<DeepgramAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::AssemblyAI => {
-            spawn_session::<AssemblyAIAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::Soniox => {
-            spawn_session::<SonioxAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::Fireworks => {
-            spawn_session::<FireworksAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::OpenAI => {
-            spawn_session::<OpenAIAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::Gladia => {
-            spawn_session::<GladiaAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::ElevenLabs => {
-            spawn_session::<ElevenLabsAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::DashScope => {
-            spawn_session::<DashScopeAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-        Provider::Mistral => {
-            spawn_session::<MistralAdapter, _, _>(api_base, resolved_key, make_stream)
-        }
-    }
-}
diff --git a/crates/transcript/examples/cli/provider/mod.rs b/crates/transcript/examples/cli/provider/mod.rs
deleted file mode 100644
index 84d8fc1547..0000000000
--- a/crates/transcript/examples/cli/provider/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod cactus;
-mod cloud;
-
-pub use cactus::CactusProvider;
-pub use cloud::CloudProvider;
diff --git a/crates/transcript/examples/cli/renderer/debug.rs b/crates/transcript/examples/cli/renderer/debug.rs
deleted file mode 100644
index 4006eb1076..0000000000
--- a/crates/transcript/examples/cli/renderer/debug.rs
+++ /dev/null
@@ -1,385 +0,0 @@
-use std::collections::HashMap;
-
-use ratatui::{
-    Frame,
-    layout::{Constraint, Layout, Rect},
-    style::Style,
-    text::{Line, Span},
-    widgets::{Block, Borders, Paragraph},
-};
-use transcript::types::TranscriptFrame;
-
-use crate::app::{App, SelectedWord};
-use crate::logger::LogBuffer;
-use crate::theme::THEME;
-
-const LABEL_WIDTH: usize = 9;
-
-fn kv(label: &str, value: impl Into<String>, style: Style) -> Line<'static> {
-    Line::from(vec![
-        Span::styled(format!("{:<LABEL_WIDTH$}", label), THEME.dim),
-        Span::styled(value.into(), style),
-    ])
-}
-
-fn section_header(title: &str) -> Line<'static> {
-    Line::from(Span::styled(title.to_string(), THEME.section_header))
-}
-
-fn dim_line(text: &str) -> Line<'static> {
-    Line::from(Span::styled(text.to_string(), THEME.dim))
-}
-
-fn truncate(s: &str, max_chars: usize) -> &str {
-    if s.chars().count() <= max_chars {
-        return s;
-    }
-    let mut end = 0;
-    for (i, _) in s.char_indices().take(max_chars) {
-        end = i;
-    }
-    &s[..end]
-}
-
-#[derive(Clone)]
-pub struct DebugSection {
-    pub title: &'static str,
-    pub entries: Vec<(&'static str, String)>,
-}
-
-pub(super) fn render_debug(frame: &mut Frame, app: &App, area: Rect, frame_data: &TranscriptFrame) {
-    if let Some(selected) = &app.selected_word {
-        let block = Block::default()
-            .borders(Borders::LEFT)
-            .border_style(THEME.debug_border)
-            .title(Span::styled(" word ", THEME.debug_border));
-        let inner = block.inner(area);
-        frame.render_widget(block, area);
-        render_word_detail(frame, selected, inner, inner.width);
-        return;
-    }
-
-    let block = Block::default()
-        .borders(Borders::LEFT)
-        .border_style(THEME.debug_border)
-        .title(Span::styled(" pipeline ", THEME.debug_border));
-
-    let inner = block.inner(area);
-    frame.render_widget(block, area);
-
-    let source_lines = render_debug_sections(app.source_debug_sections(), inner.width);
-    let source_height = source_lines.len() as u16;
-
-    let log_lines = render_log_lines(&app.log_buffer, inner.width);
-    let log_height = log_lines.len() as u16;
-
-    let [
-        event_area,
-        pipeline_area,
-        counts_area,
-        postprocess_area,
-        source_area,
-        log_area,
-    ] = Layout::vertical([
-        Constraint::Length(3),
-        Constraint::Fill(1),
-        Constraint::Length(5),
-        Constraint::Length(5),
-        Constraint::Length(source_height),
-        Constraint::Length(log_height),
-    ])
-    .areas(inner);
-
-    render_event_section(frame, app, event_area);
-    render_pipeline_section(frame, app, pipeline_area, frame_data);
-    render_counts_section(frame, app, counts_area, frame_data);
-    render_postprocess_section(frame, app, postprocess_area);
-    if source_height > 0 {
-        frame.render_widget(Paragraph::new(source_lines), source_area);
-    }
-    if log_height > 0 {
-        frame.render_widget(Paragraph::new(log_lines), log_area);
-    }
-}
-
-fn render_word_detail(frame: &mut Frame, selected: &SelectedWord, area: Rect, width: u16) {
-    let lines = match selected {
-        SelectedWord::Final { word, speaker } => {
-            let id_display =
-                truncate(word.id.as_str(), (width.saturating_sub(2)) as usize).to_string();
-            let extra = if let Some(hint) = speaker {
-                kv(
-                    "speaker",
-                    hint.speaker_index.to_string(),
-                    THEME.highlight_cyan,
-                )
-            } else {
-                kv("speaker", "—", THEME.dim)
-            };
-            let mut lines = word_timing_lines(
-                "final word",
-                word.text.trim(),
-                THEME.transcript_final,
-                word.start_ms,
-                word.end_ms,
-                word.channel,
-            );
-            lines.insert(2, kv("id", id_display, THEME.dim));
-            lines.push(extra);
-            lines
-        }
-        SelectedWord::Partial { word, stability } => {
-            let extra = if let Some(count) = stability {
-                kv(
-                    "seen",
-                    format!("×{count}"),
-                    if *count >= 3 {
-                        THEME.highlight_yellow
-                    } else {
-                        THEME.dim
-                    },
-                )
-            } else {
-                kv("seen", "—", THEME.dim)
-            };
-            let mut lines = word_timing_lines(
-                "partial word",
-                word.text.trim(),
-                THEME.transcript_partial,
-                word.start_ms,
-                word.end_ms,
-                word.channel,
-            );
-            lines.push(extra);
-            lines
-        }
-    };
-    frame.render_widget(Paragraph::new(lines), area);
-}
-
-fn word_timing_lines(
-    title: &str,
-    text: &str,
-    text_style: Style,
-    start_ms: i64,
-    end_ms: i64,
-    channel: i32,
-) -> Vec<Line<'static>> {
-    vec![
-        section_header(title),
-        kv("text", text, text_style),
-        kv("start", format!("{}ms", start_ms), THEME.highlight_cyan),
-        kv("end", format!("{}ms", end_ms), THEME.highlight_cyan),
-        kv(
-            "duration",
-            format!("{}ms", end_ms - start_ms),
-            THEME.watermark_active,
-        ),
-        kv("channel", channel.to_string(), Style::default()),
-    ]
-}
-
-fn render_event_section(frame: &mut Frame, app: &App, area: Rect) {
-    use crate::app::LastEvent;
-
-    let (label, style) = match app.last_event {
-        LastEvent::Final => ("FINAL", THEME.event_final),
-        LastEvent::Partial => ("PARTIAL", THEME.event_partial),
-        LastEvent::Correction => ("CORRECTION", THEME.event_correction),
-        LastEvent::Skipped => ("SKIPPED", THEME.event_skipped),
-    };
-
-    let lines = vec![
-        section_header("event"),
-        Line::from(vec![
-            Span::styled(label, style),
-            Span::styled(format!("  {}/{}", app.position, app.total()), THEME.dim),
-        ]),
-    ];
-
-    frame.render_widget(Paragraph::new(lines), area);
-}
-
-fn list_or_placeholder(
-    lines: &mut Vec<Line<'static>>,
-    items: Vec<Line<'static>>,
-    placeholder: &str,
-) {
-    if items.is_empty() {
-        lines.push(dim_line(placeholder));
-    } else {
-        lines.extend(items);
-    }
-}
-
-fn render_pipeline_section(frame: &mut Frame, app: &App, area: Rect, frame_data: &TranscriptFrame) {
-    let dbg = app.view.pipeline_debug();
-    let mut lines = vec![section_header("pipeline")];
-
-    let held: Vec<Line> = dbg
-        .held_words
-        .iter()
-        .map(|(ch, text)| {
-            Line::from(vec![
-                Span::styled("held  ", THEME.dim),
-                Span::styled(format!("[ch{}] ", ch), THEME.dim),
-                Span::styled(
-                    truncate(text.trim(), area.width.saturating_sub(8) as usize).to_string(),
-                    THEME.highlight_cyan,
-                ),
-            ])
-        })
-        .collect();
-    list_or_placeholder(&mut lines, held, "held  —");
-
-    let watermarks: Vec<Line> = dbg
-        .watermarks
-        .iter()
-        .map(|(ch, wm)| {
-            Line::from(vec![
-                Span::styled("wmark ", THEME.dim),
-                Span::styled(format!("[ch{}] ", ch), THEME.dim),
-                Span::styled(
-                    format!("{}ms", wm),
-                    if *wm > 0 {
-                        THEME.watermark_active
-                    } else {
-                        THEME.dim
-                    },
-                ),
-            ])
-        })
-        .collect();
-    list_or_placeholder(&mut lines, watermarks, "wmark —");
-
-    lines.push(Line::raw(""));
-
-    let timing_map: HashMap<&str, (i64, i64)> = frame_data
-        .partial_words
-        .iter()
-        .map(|w| (w.text.as_str(), (w.start_ms, w.end_ms)))
-        .collect();
-    let text_width = area.width.saturating_sub(14) as usize;
-    let partials: Vec<Line> = dbg
-        .partial_stability
-        .iter()
-        .map(|(text, seen)| {
-            let word_display = truncate(text.trim(), text_width).to_string();
-            let timing_suffix = timing_map
-                .get(text.as_str())
-                .map(|(s, e)| format!(" {s}–{e}ms"))
-                .unwrap_or_default();
-            Line::from(vec![
-                Span::styled(
-                    format!("{:<text_width$}", word_display),
-                    THEME.transcript_partial,
-                ),
-                Span::styled(
-                    format!(" ×{seen}"),
-                    if *seen >= 3 {
-                        THEME.highlight_yellow
-                    } else {
-                        THEME.dim
-                    },
-                ),
-                Span::styled(timing_suffix, THEME.dim),
-            ])
-        })
-        .collect();
-    list_or_placeholder(&mut lines, partials, "no partials");
-
-    frame.render_widget(Paragraph::new(lines), area);
-}
-
-fn render_counts_section(frame: &mut Frame, _app: &App, area: Rect, frame_data: &TranscriptFrame) {
-    let lines = vec![
-        section_header("counts"),
-        kv(
-            "finals",
-            frame_data.final_words.len().to_string(),
-            Style::default(),
-        ),
-        kv(
-            "partials",
-            frame_data.partial_words.len().to_string(),
-            Style::default(),
-        ),
-        kv(
-            "speakers",
-            frame_data.speaker_hints.len().to_string(),
-            Style::default(),
-        ),
-    ];
-
-    frame.render_widget(Paragraph::new(lines), area);
-}
-
-fn render_debug_sections(sections: Vec<DebugSection>, width: u16) -> Vec<Line<'static>> {
-    let mut lines = Vec::new();
-    for section in sections {
-        lines.push(section_header(section.title));
-        for (label, value) in section.entries {
-            let value = truncate(&value, width.saturating_sub(10) as usize).to_string();
-            lines.push(kv(label, value, THEME.metric_value));
-        }
-    }
-    lines
-}
-
-fn render_log_lines(buffer: &LogBuffer, width: u16) -> Vec<Line<'static>> {
-    let buf = buffer.lock().unwrap();
-    if buf.is_empty() {
-        return vec![];
-    }
-    let max_chars = width.saturating_sub(1) as usize;
-    let mut lines = vec![section_header("stderr")];
-    for raw in buf
-        .iter()
-        .rev()
-        .take(4)
-        .collect::<Vec<_>>()
-        .into_iter()
-        .rev()
-    {
-        let display = truncate(raw, max_chars).to_string();
-        lines.push(Line::from(Span::styled(display, THEME.dim)));
-    }
-    lines
-}
-
-fn render_postprocess_section(frame: &mut Frame, app: &App, area: Rect) {
-    let dbg = app.view.pipeline_debug();
-
-    let batch_style = if dbg.postprocess_applied > 0 {
-        THEME.highlight_yellow
-    } else {
-        THEME.dim
-    };
-    let mut lines = vec![
-        section_header("postprocess"),
-        kv("batches", dbg.postprocess_applied.to_string(), batch_style),
-    ];
-
-    match &app.last_postprocess {
-        None => {
-            lines.push(dim_line("no run yet  [p]"));
-        }
-        Some(update) => {
-            lines.push(Line::from(vec![
-                Span::styled("replaced ", THEME.dim),
-                Span::styled(update.updated.len().to_string(), THEME.highlight_yellow),
-                Span::styled(" words", THEME.dim),
-            ]));
-            if let Some(sample) = update.updated.first() {
-                let sample_text =
-                    truncate(sample.text.trim(), (area.width.saturating_sub(2)) as usize);
-                lines.push(Line::from(Span::styled(
-                    format!("↳ {sample_text}"),
-                    THEME.dim,
-                )));
-            }
-        }
-    }
-
-    frame.render_widget(Paragraph::new(lines), area);
-}
diff --git a/crates/transcript/examples/cli/renderer/mod.rs b/crates/transcript/examples/cli/renderer/mod.rs
deleted file mode 100644
index 0537eea67f..0000000000
--- a/crates/transcript/examples/cli/renderer/mod.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-pub mod debug;
-mod transcript;
-
-use ratatui::{
-    Frame,
-    layout::{Constraint, Layout, Rect},
-    text::{Line, Span},
-    widgets::{Gauge, Paragraph},
-};
-
-use crate::app::App;
-use crate::theme::THEME;
-
-const DEBUG_PANEL_WIDTH: u16 = 36;
-
-pub struct WordRegion {
-    pub index: usize,
-    pub is_final: bool,
-    pub row: u16,
-    pub col_start: u16,
-    pub col_end: u16,
-}
-
-#[derive(Default)]
-pub struct LayoutInfo {
-    pub transcript_lines: u16,
-    pub transcript_area_height: u16,
-    pub word_regions: Vec<WordRegion>,
-    pub transcript_area: Rect,
-}
-
-pub fn render(frame: &mut Frame, app: &App) -> LayoutInfo {
-    let [header_area, body_area, timeline_area, hint_area] = Layout::vertical([
-        Constraint::Length(1),
-        Constraint::Fill(1),
-        Constraint::Length(1),
-        Constraint::Length(1),
-    ])
-    .areas(frame.area());
-
-    let [transcript_area, debug_area] =
-        Layout::horizontal([Constraint::Fill(1), Constraint::Length(DEBUG_PANEL_WIDTH)])
-            .areas(body_area);
-
-    let transcript_frame = app.view.frame();
-
-    render_header(frame, app, header_area);
-    let layout = transcript::render_transcript(frame, app, transcript_area, &transcript_frame);
-    debug::render_debug(frame, app, debug_area, &transcript_frame);
-    render_timeline(frame, app, timeline_area);
-    render_hints(frame, app, hint_area);
-    layout
-}
-
-fn render_header(frame: &mut Frame, app: &App, area: Rect) {
-    let status = if app.paused {
-        "⏸ PAUSED"
-    } else {
-        "▶ PLAYING"
-    };
-    let text = format!(
-        " {} | {} | {}ms/event ",
-        app.source_name, status, app.speed_ms
-    );
-    frame.render_widget(Paragraph::new(text).style(THEME.header), area);
-}
-
-fn render_timeline(frame: &mut Frame, app: &App, area: Rect) {
-    let total = app.total();
-    let ratio = if total == 0 {
-        0.0
-    } else {
-        app.position as f64 / total as f64
-    };
-    let label = format!("{}/{}", app.position, total);
-    let gauge = Gauge::default()
-        .gauge_style(THEME.gauge)
-        .ratio(ratio)
-        .label(label);
-    frame.render_widget(gauge, area);
-}
-
-fn render_hints(frame: &mut Frame, app: &App, area: Rect) {
-    let spans = if app.selected_word.is_some() {
-        hint_spans(&[("Esc", "clear word"), ("q", "quit")])
-    } else {
-        hint_spans(&[
-            ("click", "inspect"),
-            ("Space", "pause"),
-            ("←/→", "seek"),
-            ("↑/↓", "speed"),
-            ("PgUp/Dn", "scroll"),
-            ("p", "postprocess"),
-            ("q", "quit"),
-        ])
-    };
-    frame.render_widget(Paragraph::new(Line::from(spans)), area);
-}
-
-fn hint_spans(keys: &[(&str, &str)]) -> Vec<Span<'static>> {
-    keys.iter()
-        .flat_map(|(key, desc)| {
-            [
-                Span::styled(format!(" {key} "), THEME.key),
-                Span::styled(format!(" {desc} "), THEME.key_desc),
-            ]
-        })
-        .collect()
-}
diff --git a/crates/transcript/examples/cli/renderer/transcript.rs b/crates/transcript/examples/cli/renderer/transcript.rs
deleted file mode 100644
index 11f6c60d40..0000000000
--- a/crates/transcript/examples/cli/renderer/transcript.rs
+++ /dev/null
@@ -1,228 +0,0 @@
-use ratatui::{
-    Frame,
-    layout::Rect,
-    style::Modifier,
-    text::{Line, Span},
-    widgets::{Block, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState, Wrap},
-};
-use transcript::types::TranscriptFrame;
-
-use crate::app::{App, SelectedWord};
-use crate::theme::THEME;
-
-use super::{LayoutInfo, WordRegion};
-
-pub(super) fn render_transcript(
-    frame: &mut Frame,
-    app: &App,
-    area: Rect,
-    frame_data: &TranscriptFrame,
-) -> LayoutInfo {
-    let final_count = frame_data.final_words.len();
-    let partial_count = frame_data.partial_words.len();
-
-    let spans = build_spans(app, frame_data);
-    let word_regions = compute_word_regions(final_count, partial_count, &spans, area.width);
-    let line_count = compute_line_count(&spans, area.width);
-    let scroll_offset = if app.viewport.auto_scroll {
-        line_count.saturating_sub(area.height)
-    } else {
-        app.viewport.scroll
-    };
-
-    render_paragraph(frame, spans, scroll_offset, area, line_count);
-
-    LayoutInfo {
-        transcript_lines: line_count,
-        transcript_area_height: area.height,
-        word_regions,
-        transcript_area: area,
-    }
-}
-
-fn build_spans<'a>(app: &App, frame_data: &'a TranscriptFrame) -> Vec<Span<'a>> {
-    let selected_final_idx = match &app.selected_word {
-        Some(SelectedWord::Final { word, .. }) => {
-            frame_data.final_words.iter().position(|w| w.id == word.id)
-        }
-        _ => None,
-    };
-    let selected_partial_idx = match &app.selected_word {
-        Some(SelectedWord::Partial { word, .. }) => frame_data
-            .partial_words
-            .iter()
-            .position(|w| w.text == word.text && w.start_ms == word.start_ms),
-        _ => None,
-    };
-
-    let speaker_map: std::collections::HashMap<&str, usize> = frame_data
-        .speaker_hints
-        .iter()
-        .map(|h| (h.word_id.as_str(), h.speaker_index as usize))
-        .collect();
-
-    let cursor_span =
-        (!frame_data.partial_words.is_empty()).then(|| Span::styled("▏", THEME.transcript_cursor));
-
-    frame_data
-        .final_words
-        .iter()
-        .enumerate()
-        .map(|(i, word)| {
-            let base_style = app
-                .source_word_style(word.channel, word.start_ms, word.end_ms)
-                .unwrap_or_else(|| {
-                    if let Some(&idx) = speaker_map.get(word.id.as_str()) {
-                        THEME.speaker[idx % THEME.speaker.len()]
-                    } else {
-                        THEME.transcript_final
-                    }
-                });
-            let style = if selected_final_idx == Some(i) {
-                base_style.add_modifier(Modifier::REVERSED)
-            } else {
-                base_style
-            };
-            Span::styled(word.text.clone(), style)
-        })
-        .chain(
-            frame_data
-                .partial_words
-                .iter()
-                .enumerate()
-                .map(|(i, word)| {
-                    let base_style = app
-                        .source_word_style(word.channel, word.start_ms, word.end_ms)
-                        .unwrap_or(THEME.transcript_partial);
-                    let style = if selected_partial_idx == Some(i) {
-                        base_style.add_modifier(Modifier::REVERSED)
-                    } else {
-                        base_style
-                    };
-                    Span::styled(word.text.clone(), style)
-                }),
-        )
-        .chain(cursor_span)
-        .collect()
-}
-
-fn render_paragraph(
-    frame: &mut Frame,
-    spans: Vec<Span>,
-    scroll_offset: u16,
-    area: Rect,
-    line_count: u16,
-) {
-    let lines = if spans.is_empty() {
-        vec![]
-    } else {
-        vec![Line::from(spans)]
-    };
-
-    frame.render_widget(
-        Paragraph::new(lines)
-            .block(Block::default())
-            .wrap(Wrap { trim: false })
-            .scroll((scroll_offset, 0)),
-        area,
-    );
-
-    if line_count > area.height {
-        let mut scrollbar_state =
-            ScrollbarState::new(line_count as usize).position(scroll_offset as usize);
-        frame.render_stateful_widget(
-            Scrollbar::new(ScrollbarOrientation::VerticalRight)
-                .begin_symbol(None)
-                .end_symbol(None)
-                .track_symbol(None)
-                .thumb_symbol("▐"),
-            area,
-            &mut scrollbar_state,
-        );
-    }
-}
-
-fn compute_word_regions(
-    final_count: usize,
-    partial_count: usize,
-    spans: &[Span],
-    area_width: u16,
-) -> Vec<WordRegion> {
-    if area_width == 0 {
-        return Vec::new();
-    }
-
-    let mut regions = Vec::new();
-    let mut row: u16 = 0;
-    let mut col: u16 = 0;
-
-    let word_span_count = final_count + partial_count;
-
-    for (span_idx, span) in spans.iter().enumerate() {
-        if span_idx >= word_span_count {
-            break;
-        }
-
-        let is_final = span_idx < final_count;
-        let word_index = if is_final {
-            span_idx
-        } else {
-            span_idx - final_count
-        };
-
-        let text = span.content.as_ref();
-        let char_count = text.chars().count() as u16;
-
-        if char_count == 0 {
-            regions.push(WordRegion {
-                index: word_index,
-                is_final,
-                row,
-                col_start: col,
-                col_end: col,
-            });
-            continue;
-        }
-
-        if col > 0 && col + char_count > area_width {
-            row += 1;
-            col = 0;
-            // Strip leading spaces when wrapping to next line
-            let trimmed = text.trim_start_matches(' ');
-            let leading = (char_count - trimmed.chars().count() as u16).min(char_count);
-            let content_width = char_count - leading;
-            regions.push(WordRegion {
-                index: word_index,
-                is_final,
-                row,
-                col_start: col,
-                col_end: col + content_width,
-            });
-            col += content_width;
-        } else {
-            regions.push(WordRegion {
-                index: word_index,
-                is_final,
-                row,
-                col_start: col,
-                col_end: col + char_count,
-            });
-            col += char_count;
-        }
-
-        if col >= area_width {
-            row += col / area_width;
-            col %= area_width;
-        }
-    }
-
-    regions
-}
-
-fn compute_line_count(spans: &[Span], area_width: u16) -> u16 {
-    if area_width == 0 {
-        return 1;
-    }
-    let total_chars: usize = spans.iter().map(|s| s.content.chars().count()).sum();
-    ((total_chars + area_width as usize - 1) / area_width as usize).max(1) as u16
-}
diff --git a/crates/transcript/examples/cli/source.rs b/crates/transcript/examples/cli/source.rs
deleted file mode 100644
index 5917f638f6..0000000000
--- a/crates/transcript/examples/cli/source.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-use std::time::Duration;
-
-use futures_util::{Stream, StreamExt};
-use hypr_audio_utils::AudioFormatExt;
-use owhisper_interface::stream::StreamResponse;
-use owhisper_interface::{ControlMessage, MixedMessage};
-
-use crate::feed::TranscriptFeed;
-use crate::renderer::debug::DebugSection;
-
-pub struct FixtureSource {
-    name: String,
-    responses: Vec<StreamResponse>,
-}
-
-impl FixtureSource {
-    pub fn from_json(name: impl Into<String>, json: &str) -> Self {
-        let responses: Vec<StreamResponse> =
-            serde_json::from_str(json).expect("fixture must parse as StreamResponse[]");
-        Self {
-            name: name.into(),
-            responses,
-        }
-    }
-}
-
-impl TranscriptFeed for FixtureSource {
-    fn total(&self) -> usize {
-        self.responses.len()
-    }
-
-    fn get(&self, index: usize) -> Option<&StreamResponse> {
-        self.responses.get(index)
-    }
-
-    fn poll_next(&mut self) -> Option<&StreamResponse> {
-        None
-    }
-
-    fn is_live(&self) -> bool {
-        false
-    }
-
-    fn debug_sections(&self) -> Vec<DebugSection> {
-        vec![DebugSection {
-            title: "fixture",
-            entries: vec![
-                ("name", self.name.clone()),
-                ("events", self.responses.len().to_string()),
-            ],
-        }]
-    }
-}
-
-pub fn throttled_audio_stream<S>(
-    source: S,
-) -> impl Stream<Item = MixedMessage<bytes::Bytes, ControlMessage>> + Send + Unpin + 'static
-where
-    S: AudioFormatExt + Send + Unpin + 'static,
-{
-    let chunks = source.to_i16_le_chunks(16000, 1600);
-    Box::pin(tokio_stream::StreamExt::throttle(
-        chunks.map(MixedMessage::Audio),
-        Duration::from_millis(100),
-    ))
-}
diff --git a/crates/transcript/examples/cli/theme.rs b/crates/transcript/examples/cli/theme.rs
deleted file mode 100644
index 2ec68e20e0..0000000000
--- a/crates/transcript/examples/cli/theme.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use ratatui::style::{Color, Modifier, Style};
-
-pub struct Theme {
-    pub header: Style,
-    pub transcript_final: Style,
-    pub transcript_partial: Style,
-    pub transcript_cursor: Style,
-    pub transcript_pending_correction: Style,
-    pub debug_border: Style,
-    pub section_header: Style,
-    pub dim: Style,
-    pub event_final: Style,
-    pub event_partial: Style,
-    pub event_correction: Style,
-    pub event_skipped: Style,
-    pub key: Style,
-    pub key_desc: Style,
-    pub highlight_cyan: Style,
-    pub highlight_yellow: Style,
-    pub watermark_active: Style,
-    pub metric_value: Style,
-    pub gauge: Style,
-    pub speaker: [Style; 6],
-}
-
-pub const THEME: Theme = Theme {
-    header: Style::new().fg(Color::DarkGray),
-    transcript_final: Style::new(),
-    transcript_partial: Style::new()
-        .fg(Color::DarkGray)
-        .add_modifier(Modifier::ITALIC),
-    transcript_cursor: Style::new().fg(Color::DarkGray),
-    transcript_pending_correction: Style::new().fg(Color::Red),
-    debug_border: Style::new().fg(Color::DarkGray),
-    section_header: Style::new()
-        .fg(Color::DarkGray)
-        .add_modifier(Modifier::UNDERLINED),
-    dim: Style::new().fg(Color::DarkGray),
-    event_final: Style::new().fg(Color::Green).add_modifier(Modifier::BOLD),
-    event_partial: Style::new().fg(Color::Yellow).add_modifier(Modifier::BOLD),
-    event_correction: Style::new().fg(Color::Magenta).add_modifier(Modifier::BOLD),
-    event_skipped: Style::new()
-        .fg(Color::DarkGray)
-        .add_modifier(Modifier::BOLD),
-    key: Style::new().fg(Color::Rgb(20, 20, 20)).bg(Color::DarkGray),
-    key_desc: Style::new().fg(Color::DarkGray),
-    highlight_cyan: Style::new().fg(Color::Cyan),
-    highlight_yellow: Style::new().fg(Color::Yellow),
-    watermark_active: Style::new().fg(Color::White),
-    metric_value: Style::new().fg(Color::Cyan),
-    gauge: Style::new().fg(Color::White).bg(Color::DarkGray),
-    speaker: [
-        Style::new().fg(Color::Cyan),
-        Style::new().fg(Color::Green),
-        Style::new().fg(Color::Magenta),
-        Style::new().fg(Color::Yellow),
-        Style::new().fg(Color::LightBlue),
-        Style::new().fg(Color::LightRed),
-    ],
-};
diff --git a/crates/transcript/examples/cli/viewport.rs b/crates/transcript/examples/cli/viewport.rs
deleted file mode 100644
index a9c10a3049..0000000000
--- a/crates/transcript/examples/cli/viewport.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use ratatui::layout::Rect;
-
-use crate::renderer::{LayoutInfo, WordRegion};
-
-pub struct ViewportState {
-    pub scroll: u16,
-    pub auto_scroll: bool,
-    pub content_lines: u16,
-    pub visible_height: u16,
-    pub word_regions: Vec<WordRegion>,
-    pub area: Rect,
-}
-
-impl ViewportState {
-    pub fn new() -> Self {
-        Self {
-            scroll: 0,
-            auto_scroll: true,
-            content_lines: 0,
-            visible_height: 0,
-            word_regions: Vec::new(),
-            area: Rect::default(),
-        }
-    }
-
-    pub fn update(&mut self, layout: LayoutInfo) {
-        self.content_lines = layout.transcript_lines;
-        self.visible_height = layout.transcript_area_height;
-        self.word_regions = layout.word_regions;
-        self.area = layout.transcript_area;
-    }
-
-    pub fn current_scroll_offset(&self) -> u16 {
-        if self.auto_scroll {
-            self.content_lines.saturating_sub(self.visible_height)
-        } else {
-            self.scroll
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.scroll = 0;
-        self.auto_scroll = true;
-        self.content_lines = 0;
-        self.visible_height = 0;
-        self.word_regions.clear();
-        self.area = Rect::default();
-    }
-
-    pub fn scroll_up(&mut self, amount: u16) {
-        self.auto_scroll = false;
-        self.scroll = self.current_scroll_offset().saturating_sub(amount);
-    }
-
-    pub fn scroll_down(&mut self, amount: u16) {
-        let max = self.content_lines.saturating_sub(self.visible_height);
-        let next = (self.current_scroll_offset() + amount).min(max);
-        if next >= max {
-            self.auto_scroll = true;
-        }
-        self.scroll = next;
-    }
-}
diff --git a/crates/transcript/src/accumulator.rs b/crates/transcript/src/accumulator.rs
new file mode 100644
index 0000000000..8aa4e7753c
--- /dev/null
+++ b/crates/transcript/src/accumulator.rs
@@ -0,0 +1,91 @@
+use super::types::{FinalizedWord, PartialWord, RawWord, SpeakerHint, WordState};
+use super::words::{dedup, finalize_words, stitch, to_partial};
+
+pub(super) struct ChannelState {
+    watermark: i64,
+    held: Option<RawWord>,
+    partials: Vec<RawWord>,
+}
+
+impl ChannelState {
+    pub(super) fn new() -> Self {
+        Self {
+            watermark: 0,
+            held: None,
+            partials: Vec::new(),
+        }
+    }
+
+    /// Process a confirmed final batch.
+    ///
+    /// Partials that end before this batch starts are promoted to final.
+    /// Partials overlapping the final range are dropped.
+    pub(super) fn apply_final(
+        &mut self,
+        words: Vec<RawWord>,
+        state: WordState,
+    ) -> (Vec<FinalizedWord>, Vec<SpeakerHint>) {
+        let new_words = dedup(words, self.watermark);
+        if new_words.is_empty() {
+            return (vec![], vec![]);
+        }
+
+        let final_start = new_words.first().map_or(0, |w| w.start_ms);
+        let final_end = new_words.last().map_or(0, |w| w.end_ms);
+
+        let (pre_final, rest): (Vec<_>, Vec<_>) = std::mem::take(&mut self.partials)
+            .into_iter()
+            .partition(|w| w.end_ms <= final_start);
+
+        self.partials = rest
+            .into_iter()
+            .filter(|w| w.start_ms > final_end)
+            .collect();
+        self.watermark = final_end;
+
+        let mut to_finalize: Vec<RawWord> = pre_final;
+        let (emitted, held) = stitch(self.held.take(), new_words);
+        self.held = held;
+        to_finalize.extend(emitted);
+
+        finalize_words(to_finalize, state)
+    }
+
+    /// Update the partial buffer with a simple time-range replacement.
+    pub(super) fn apply_partial(&mut self, words: Vec<RawWord>) {
+        let words = dedup(words, self.watermark);
+        if words.is_empty() {
+            return;
+        }
+
+        let first_start = words.first().map_or(0, |w| w.start_ms);
+        let last_end = words.last().map_or(0, |w| w.end_ms);
+
+        let before = self
+            .partials
+            .iter()
+            .filter(|w| w.end_ms <= first_start)
+            .cloned();
+        let after = self
+            .partials
+            .iter()
+            .filter(|w| w.start_ms >= last_end)
+            .cloned();
+
+        self.partials = before.chain(words).chain(after).collect();
+    }
+
+    /// Drain remaining state at session end.
+    ///
+    /// The held word is always promoted. Remaining partials are promoted as
+    /// final (they survived the session without being superseded).
+    pub(super) fn drain(&mut self) -> (Vec<FinalizedWord>, Vec<SpeakerHint>) {
+        let mut raw: Vec<RawWord> = self.held.take().into_iter().collect();
+        raw.extend(std::mem::take(&mut self.partials));
+        finalize_words(raw, WordState::Final)
+    }
+
+    pub(super) fn current_partials(&self) -> impl Iterator<Item = PartialWord> + '_ {
+        self.partials.iter().chain(self.held.iter()).map(to_partial)
+    }
+}
diff --git a/crates/transcript/src/accumulator/channel.rs b/crates/transcript/src/accumulator/channel.rs
deleted file mode 100644
index b25ed21ce7..0000000000
--- a/crates/transcript/src/accumulator/channel.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use crate::id::IdGenerator;
-use crate::types::{RawWord, SpeakerHint, TranscriptWord};
-
-use super::words::{
-    PartialEntry, dedup, finalize_words, splice_partials, stitch, strip_overlap_entries,
-};
-
-/// Partials seen in fewer than this many consecutive frames are noise; drop them at flush.
-const MIN_STABLE_FRAMES: u32 = 2;
-
-pub(super) struct ChannelState {
-    watermark: i64,
-    held: Option<RawWord>,
-    partials: Vec<PartialEntry>,
-}
-
-impl ChannelState {
-    pub(super) fn new() -> Self {
-        Self {
-            watermark: 0,
-            held: None,
-            partials: Vec::new(),
-        }
-    }
-
-    pub(super) fn partials(&self) -> impl Iterator<Item = &RawWord> {
-        self.partials.iter().map(|e| &e.word)
-    }
-
-    pub(super) fn partial_entries(&self) -> impl Iterator<Item = &PartialEntry> {
-        self.partials.iter()
-    }
-
-    pub(super) fn held(&self) -> Option<&RawWord> {
-        self.held.as_ref()
-    }
-
-    pub(super) fn watermark(&self) -> i64 {
-        self.watermark
-    }
-
-    /// Process a confirmed final batch.
-    ///
-    /// Two things happen in order:
-    ///
-    /// 1. Any partial words whose time range ends *before* this batch starts
-    ///    are promoted to final. The provider is confirming words after them,
-    ///    so those partials are guaranteed not to change anymore.
-    ///
-    /// 2. The final words themselves are processed (dedup, stitch, emit).
-    pub(super) fn apply_final(
-        &mut self,
-        words: Vec<RawWord>,
-        id_gen: &mut dyn IdGenerator,
-    ) -> (Vec<TranscriptWord>, Vec<SpeakerHint>) {
-        let new_words = dedup(words, self.watermark);
-        if new_words.is_empty() {
-            return (vec![], vec![]);
-        }
-
-        let final_start = new_words.first().map_or(0, |w| w.start_ms);
-        let final_end = new_words.last().map_or(0, |w| w.end_ms);
-
-        // Promote partials that come before this final batch.
-        let (pre_final, rest): (Vec<_>, Vec<_>) = std::mem::take(&mut self.partials)
-            .into_iter()
-            .partition(|e| e.word.end_ms <= final_start);
-
-        // Drop partials that overlap the final range; keep those after it.
-        self.partials = strip_overlap_entries(rest, final_end);
-
-        self.watermark = final_end;
-
-        let mut to_finalize: Vec<RawWord> = pre_final.into_iter().map(|e| e.word).collect();
-
-        let (emitted, held) = stitch(self.held.take(), new_words);
-        self.held = held;
-        to_finalize.extend(emitted);
-
-        finalize_words(to_finalize, id_gen)
-    }
-
-    /// Update the partial buffer. No promotion happens here — partials are
-    /// promoted either by an incoming final (see `apply_final`) or at flush.
-    pub(super) fn apply_partial(&mut self, words: Vec<RawWord>) {
-        // Filter words already covered by the watermark so that words
-        // finalized mid-session cannot re-enter the partial buffer.
-        let words = dedup(words, self.watermark);
-        if words.is_empty() {
-            return;
-        }
-        self.partials = splice_partials(&self.partials, words);
-    }
-
-    /// Drain remaining state at session end.
-    ///
-    /// The held word (ASR-confirmed, withheld for cross-batch stitching) is
-    /// always promoted. Partials stable across at least [`MIN_STABLE_FRAMES`]
-    /// consecutive frames are promoted; single-shot partials are dropped as
-    /// noise.
-    pub(super) fn drain(
-        &mut self,
-        id_gen: &mut dyn IdGenerator,
-    ) -> (Vec<TranscriptWord>, Vec<SpeakerHint>) {
-        let mut raw: Vec<RawWord> = self.held.take().into_iter().collect();
-
-        raw.extend(
-            std::mem::take(&mut self.partials)
-                .into_iter()
-                .filter(|e| e.consecutive_seen >= MIN_STABLE_FRAMES)
-                .map(|e| e.word),
-        );
-
-        finalize_words(raw, id_gen)
-    }
-}
diff --git a/crates/transcript/src/accumulator/mod.rs b/crates/transcript/src/accumulator/mod.rs
deleted file mode 100644
index 3b0ce18f86..0000000000
--- a/crates/transcript/src/accumulator/mod.rs
+++ /dev/null
@@ -1,735 +0,0 @@
-//! # Transcript-as-Oracle Accumulator
-//!
-//! The transcript string in each ASR response is the **sole source of truth**
-//! for word boundaries. Tokens are sub-word fragments with timing metadata;
-//! the transcript tells us which fragments belong to the same word.
-//!
-//! ## Two-level design
-//!
-//! **Within a response** — `assemble` aligns tokens to the transcript via
-//! `spacing_from_transcript`. A space in the transcript means "new word";
-//! no space means "same word." No timing heuristics.
-//!
-//! **Across responses** — `stitch` handles the one case where no transcript
-//! spans both sides: when a provider splits a word across two final responses
-//! (e.g. Korean particles like "시스템" + "을" → "시스템을"). This uses a
-//! timing-based heuristic because no cross-response transcript exists.
-
-mod channel;
-pub(crate) mod words;
-
-use std::collections::BTreeMap;
-
-use crate::id::{IdGenerator, UuidIdGen};
-use crate::input::TranscriptInput;
-use crate::types::{PartialWord, TranscriptUpdate};
-
-use channel::ChannelState;
-use words::ensure_space_prefix_partial;
-
-/// Accumulates streaming ASR responses into clean, deduplicated transcript data.
-///
-/// Each [`TranscriptAccumulator::process`] call returns a [`TranscriptUpdate`]
-/// with:
-/// - `new_final_words`: words that became final since the last update
-/// - `speaker_hints`: speaker associations for the newly finalized words
-/// - `partial_words`: current in-progress words across all channels (global snapshot)
-///
-/// Call [`TranscriptAccumulator::flush`] at session end to drain held/partial
-/// words. For rendering use cases that want a complete frame snapshot rather
-/// than deltas, use [`crate::view::TranscriptView`] instead.
-pub struct TranscriptAccumulator {
-    channels: BTreeMap<i32, ChannelState>,
-    id_gen: Box<dyn IdGenerator>,
-}
-
-impl TranscriptAccumulator {
-    pub fn new() -> Self {
-        Self::with_config(UuidIdGen)
-    }
-
-    pub fn with_config(id_gen: impl IdGenerator + 'static) -> Self {
-        Self {
-            channels: BTreeMap::new(),
-            id_gen: Box::new(id_gen),
-        }
-    }
-
-    pub fn process(&mut self, input: TranscriptInput) -> Option<TranscriptUpdate> {
-        let (words, is_final) = match input {
-            TranscriptInput::Final { words } => (words, true),
-            TranscriptInput::Partial { words } => (words, false),
-            TranscriptInput::Correction { .. } => return None,
-        };
-
-        if words.is_empty() {
-            return None;
-        }
-
-        let channel = words[0].channel;
-
-        let (new_final_words, speaker_hints) = {
-            let (channels, id_gen) = (&mut self.channels, &mut self.id_gen);
-            let state = channels.entry(channel).or_insert_with(ChannelState::new);
-
-            if is_final {
-                state.apply_final(words, &mut **id_gen)
-            } else {
-                state.apply_partial(words);
-                (vec![], vec![])
-            }
-        };
-
-        Some(TranscriptUpdate {
-            new_final_words,
-            speaker_hints,
-            partial_words: self.all_partials(),
-        })
-    }
-
-    pub fn flush(&mut self) -> TranscriptUpdate {
-        let mut new_final_words = Vec::new();
-        let mut speaker_hints = Vec::new();
-
-        for state in self.channels.values_mut() {
-            let (words, hints) = state.drain(&mut *self.id_gen);
-            new_final_words.extend(words);
-            speaker_hints.extend(hints);
-        }
-
-        TranscriptUpdate {
-            new_final_words,
-            speaker_hints,
-            partial_words: vec![],
-        }
-    }
-
-    pub(crate) fn held_words(&self) -> Vec<(i32, String)> {
-        self.channels
-            .iter()
-            .filter_map(|(ch, state)| state.held().map(|w| (*ch, w.text.clone())))
-            .collect()
-    }
-
-    pub(crate) fn watermarks(&self) -> Vec<(i32, i64)> {
-        self.channels
-            .iter()
-            .map(|(ch, state)| (*ch, state.watermark()))
-            .collect()
-    }
-
-    pub(crate) fn partial_stability(&self) -> Vec<(String, u32)> {
-        self.channels
-            .values()
-            .flat_map(|state| {
-                state
-                    .partial_entries()
-                    .map(|e| (e.word.text.clone(), e.consecutive_seen))
-            })
-            .collect()
-    }
-
-    pub(crate) fn all_partials(&self) -> Vec<PartialWord> {
-        let mut partials: Vec<PartialWord> = self
-            .channels
-            .values()
-            .flat_map(|state| state.partials().map(|w| w.to_partial()))
-            .collect();
-
-        if let Some(first) = partials.first_mut() {
-            ensure_space_prefix_partial(first);
-        }
-
-        partials
-    }
-}
-
-impl Default for TranscriptAccumulator {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::id::SequentialIdGen;
-    use crate::input::TranscriptInput;
-    use crate::types::TranscriptWord;
-    use owhisper_interface::stream::{Alternatives, Channel, Metadata, ModelInfo};
-
-    fn raw_word(
-        text: &str,
-        start: f64,
-        end: f64,
-        speaker: Option<i32>,
-    ) -> owhisper_interface::stream::Word {
-        owhisper_interface::stream::Word {
-            word: text.to_string(),
-            start,
-            end,
-            confidence: 1.0,
-            speaker,
-            punctuated_word: Some(text.to_string()),
-            language: None,
-        }
-    }
-
-    fn response(
-        words: &[(&str, f64, f64, Option<i32>)],
-        transcript: &str,
-        is_final: bool,
-        channel_idx: i32,
-    ) -> owhisper_interface::stream::StreamResponse {
-        owhisper_interface::stream::StreamResponse::TranscriptResponse {
-            start: 0.0,
-            duration: 0.0,
-            is_final,
-            speech_final: is_final,
-            from_finalize: false,
-            channel: Channel {
-                alternatives: vec![Alternatives {
-                    transcript: transcript.to_string(),
-                    words: words
-                        .iter()
-                        .map(|&(t, s, e, sp)| raw_word(t, s, e, sp))
-                        .collect(),
-                    confidence: 1.0,
-                    languages: vec![],
-                }],
-            },
-            metadata: Metadata {
-                request_id: String::new(),
-                model_info: ModelInfo {
-                    name: String::new(),
-                    version: String::new(),
-                    arch: String::new(),
-                },
-                model_uuid: String::new(),
-                extra: None,
-            },
-            channel_index: vec![channel_idx],
-        }
-    }
-
-    fn partial(
-        words: &[(&str, f64, f64)],
-        transcript: &str,
-    ) -> owhisper_interface::stream::StreamResponse {
-        let ws: Vec<_> = words.iter().map(|&(t, s, e)| (t, s, e, None)).collect();
-        response(&ws, transcript, false, 0)
-    }
-
-    fn finalize(
-        words: &[(&str, f64, f64)],
-        transcript: &str,
-    ) -> owhisper_interface::stream::StreamResponse {
-        let ws: Vec<_> = words.iter().map(|&(t, s, e)| (t, s, e, None)).collect();
-        response(&ws, transcript, true, 0)
-    }
-
-    fn finalize_with_speakers(
-        words: &[(&str, f64, f64, Option<i32>)],
-        transcript: &str,
-    ) -> owhisper_interface::stream::StreamResponse {
-        response(words, transcript, true, 0)
-    }
-
-    /// Convert a StreamResponse through the input layer and process it.
-    fn process_response(
-        acc: &mut TranscriptAccumulator,
-        sr: &owhisper_interface::stream::StreamResponse,
-    ) -> Option<TranscriptUpdate> {
-        TranscriptInput::from_stream_response(sr).and_then(|input| acc.process(input))
-    }
-
-    fn replay(responses: &[owhisper_interface::stream::StreamResponse]) -> Vec<TranscriptWord> {
-        let mut acc = TranscriptAccumulator::new();
-        let mut words = Vec::new();
-
-        for r in responses {
-            if let Some(update) = process_response(&mut acc, r) {
-                words.extend(update.new_final_words);
-            }
-        }
-
-        words.extend(acc.flush().new_final_words);
-        words
-    }
-
-    fn assert_valid_output(words: &[TranscriptWord]) {
-        assert!(!words.is_empty(), "must produce words");
-
-        assert!(
-            words.iter().all(|w| !w.id.is_empty()),
-            "all words must have IDs"
-        );
-
-        let ids: std::collections::HashSet<_> = words.iter().map(|w| &w.id).collect();
-        assert_eq!(ids.len(), words.len(), "IDs must be unique");
-
-        for w in words {
-            assert!(
-                !w.text.trim().is_empty(),
-                "word text must not be blank: {w:?}"
-            );
-            assert!(
-                w.text.starts_with(' '),
-                "word must start with space: {:?}",
-                w.text
-            );
-        }
-
-        for ch in words
-            .iter()
-            .map(|w| w.channel)
-            .collect::<std::collections::BTreeSet<_>>()
-        {
-            let cw: Vec<_> = words.iter().filter(|w| w.channel == ch).collect();
-            assert!(
-                cw.windows(2).all(|w| w[0].start_ms <= w[1].start_ms),
-                "channel {ch} must be chronological"
-            );
-        }
-    }
-
-    #[test]
-    fn partial_update_exposes_current_words() {
-        let mut acc = TranscriptAccumulator::new();
-
-        let update = process_response(
-            &mut acc,
-            &partial(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        )
-        .unwrap();
-
-        assert!(update.new_final_words.is_empty());
-        assert_eq!(update.partial_words.len(), 2);
-        assert_eq!(
-            update
-                .partial_words
-                .iter()
-                .map(|w| &w.text)
-                .collect::<Vec<_>>(),
-            [" Hello", " world"]
-        );
-    }
-
-    #[test]
-    fn partial_splices_into_existing_window() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(
-            &mut acc,
-            &partial(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        );
-
-        let update = process_response(
-            &mut acc,
-            &partial(
-                &[
-                    (" Hello", 0.1, 0.5),
-                    (" world", 0.6, 0.9),
-                    (" today", 1.0, 1.3),
-                ],
-                " Hello world today",
-            ),
-        )
-        .unwrap();
-
-        assert_eq!(update.partial_words.len(), 3);
-        assert_eq!(
-            update
-                .partial_words
-                .iter()
-                .map(|w| &w.text)
-                .collect::<Vec<_>>(),
-            [" Hello", " world", " today"]
-        );
-    }
-
-    #[test]
-    fn final_emits_prefix_and_holds_last() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(
-            &mut acc,
-            &partial(
-                &[(" Hello", 0.1, 0.5), (" world", 0.55, 0.9)],
-                " Hello world",
-            ),
-        );
-
-        let update = process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.55, 0.9)],
-                " Hello world",
-            ),
-        )
-        .unwrap();
-
-        assert_eq!(update.new_final_words.len(), 1);
-        assert_eq!(update.new_final_words[0].text, " Hello");
-        assert!(update.partial_words.is_empty());
-
-        let flushed = acc.flush();
-        assert_eq!(flushed.new_final_words.len(), 1);
-        assert_eq!(flushed.new_final_words[0].text, " world");
-    }
-
-    #[test]
-    fn final_deduplicates_repeated_response() {
-        let mut acc = TranscriptAccumulator::new();
-
-        let r = finalize(
-            &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-            " Hello world",
-        );
-
-        let first = process_response(&mut acc, &r).unwrap();
-        let second = process_response(&mut acc, &r).unwrap();
-
-        assert!(!first.new_final_words.is_empty());
-        assert!(second.new_final_words.is_empty());
-    }
-
-    #[test]
-    fn final_clears_overlapping_partials() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(
-            &mut acc,
-            &partial(
-                &[
-                    (" Hello", 0.1, 0.5),
-                    (" world", 0.6, 1.0),
-                    (" test", 1.1, 1.5),
-                ],
-                " Hello world test",
-            ),
-        );
-
-        let update = process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 1.0)],
-                " Hello world",
-            ),
-        )
-        .unwrap();
-
-        assert_eq!(update.partial_words.len(), 1);
-        assert_eq!(update.partial_words[0].text, " test");
-    }
-
-    #[test]
-    fn all_final_words_have_ids() {
-        let mut acc = TranscriptAccumulator::new();
-
-        let update = process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        )
-        .unwrap();
-
-        assert!(update.new_final_words.iter().all(|w| !w.id.is_empty()));
-
-        let flushed = acc.flush();
-        assert!(flushed.new_final_words.iter().all(|w| !w.id.is_empty()));
-    }
-
-    #[test]
-    fn flush_drains_held_word() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        );
-
-        let flushed = acc.flush();
-
-        assert_eq!(flushed.new_final_words.len(), 1);
-        assert_eq!(flushed.new_final_words[0].text, " world");
-        assert!(!flushed.new_final_words[0].id.is_empty());
-    }
-
-    #[test]
-    fn flush_drains_partials_beyond_final_range() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(&mut acc, &partial(&[(" later", 5.0, 5.5)], " later"));
-
-        process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        );
-
-        let flushed = acc.flush();
-
-        let texts: Vec<_> = flushed.new_final_words.iter().map(|w| &w.text).collect();
-        assert!(
-            texts.contains(&&" world".to_string()) || texts.contains(&&" later".to_string()),
-            "flush must drain held + partials: {texts:?}"
-        );
-        assert!(flushed.new_final_words.iter().all(|w| !w.id.is_empty()));
-    }
-
-    #[test]
-    fn flush_on_empty_accumulator_is_empty() {
-        let mut acc = TranscriptAccumulator::new();
-        let flushed = acc.flush();
-        assert!(flushed.new_final_words.is_empty());
-        assert!(flushed.partial_words.is_empty());
-        assert!(flushed.speaker_hints.is_empty());
-    }
-
-    #[test]
-    fn flush_drops_single_shot_partials() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(&mut acc, &partial(&[(" maybe", 0.0, 0.5)], " maybe"));
-
-        let flushed = acc.flush();
-        assert!(
-            flushed.new_final_words.is_empty(),
-            "partial seen only once must be dropped as noise"
-        );
-    }
-
-    #[test]
-    fn flush_promotes_stable_partials() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(&mut acc, &partial(&[(" stable", 0.0, 0.5)], " stable"));
-        process_response(&mut acc, &partial(&[(" stable", 0.0, 0.5)], " stable"));
-
-        let flushed = acc.flush();
-        assert_eq!(flushed.new_final_words.len(), 1);
-        assert_eq!(flushed.new_final_words[0].text, " stable");
-    }
-
-    #[test]
-    fn flush_promotes_held_word() {
-        let mut acc = TranscriptAccumulator::new();
-
-        process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        );
-
-        let flushed = acc.flush();
-        assert_eq!(flushed.new_final_words.len(), 1);
-        assert_eq!(flushed.new_final_words[0].text, " world");
-    }
-
-    #[test]
-    fn non_transcript_responses_produce_no_update() {
-        let mut acc = TranscriptAccumulator::new();
-        let ignored = owhisper_interface::stream::StreamResponse::TerminalResponse {
-            request_id: "r".into(),
-            created: "now".into(),
-            duration: 1.0,
-            channels: 1,
-        };
-        assert!(TranscriptInput::from_stream_response(&ignored).is_none());
-        assert!(
-            acc.process(TranscriptInput::Final { words: vec![] })
-                .is_none()
-        );
-    }
-
-    #[test]
-    fn speaker_hints_extracted_from_final_words() {
-        let mut acc = TranscriptAccumulator::new();
-
-        let update = process_response(
-            &mut acc,
-            &finalize_with_speakers(
-                &[(" Hello", 0.1, 0.5, Some(0)), (" world", 0.6, 0.9, Some(1))],
-                " Hello world",
-            ),
-        )
-        .unwrap();
-
-        assert_eq!(update.new_final_words.len(), 1);
-        assert_eq!(update.speaker_hints.len(), 1);
-        assert_eq!(update.speaker_hints[0].speaker_index, 0);
-        assert_eq!(
-            update.speaker_hints[0].word_id,
-            update.new_final_words[0].id
-        );
-
-        let flushed = acc.flush();
-        assert_eq!(flushed.new_final_words.len(), 1);
-        assert_eq!(flushed.speaker_hints.len(), 1);
-        assert_eq!(flushed.speaker_hints[0].speaker_index, 1);
-    }
-
-    #[test]
-    fn no_speaker_hints_when_speaker_is_none() {
-        let mut acc = TranscriptAccumulator::new();
-
-        let update = process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        )
-        .unwrap();
-
-        assert!(update.speaker_hints.is_empty());
-    }
-
-    #[test]
-    fn sequential_id_gen_produces_deterministic_ids() {
-        let mut acc = TranscriptAccumulator::with_config(SequentialIdGen::new());
-
-        let update = process_response(
-            &mut acc,
-            &finalize(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-            ),
-        )
-        .unwrap();
-
-        assert_eq!(update.new_final_words[0].id, "0");
-
-        let flushed = acc.flush();
-        assert_eq!(flushed.new_final_words[0].id, "1");
-    }
-
-    #[test]
-    fn pre_final_partials_are_promoted_when_final_arrives() {
-        let mut acc = TranscriptAccumulator::new();
-
-        // Two partial words arrive before any final.
-        process_response(
-            &mut acc,
-            &partial(
-                &[(" hello", 0.0, 0.5), (" world", 0.6, 0.9)],
-                " hello world",
-            ),
-        );
-
-        // A final batch arrives for words *after* the partials.
-        let update =
-            process_response(&mut acc, &finalize(&[(" later", 1.0, 1.5)], " later")).unwrap();
-
-        // Both partials (end_ms <= 1000ms = later.start_ms) are promoted,
-        // plus "later" is held by stitch (single-word batch).
-        assert!(
-            update.new_final_words.iter().any(|w| w.text == " hello"),
-            "pre-final partial ' hello' must be promoted: {:?}",
-            update.new_final_words,
-        );
-        assert!(
-            update.new_final_words.iter().any(|w| w.text == " world"),
-            "pre-final partial ' world' must be promoted: {:?}",
-            update.new_final_words,
-        );
-    }
-
-    macro_rules! fixture_test {
-        ($test_name:ident, $json:expr) => {
-            #[test]
-            fn $test_name() {
-                let responses: Vec<owhisper_interface::stream::StreamResponse> =
-                    serde_json::from_str($json).expect("fixture must parse as StreamResponse[]");
-                assert_valid_output(&replay(&responses));
-            }
-        };
-    }
-
-    fixture_test!(
-        deepgram_fixture_produces_valid_output,
-        hypr_data::english_1::DEEPGRAM_JSON
-    );
-    fixture_test!(
-        soniox_fixture_produces_valid_output,
-        hypr_data::english_1::SONIOX_JSON
-    );
-    fixture_test!(
-        soniox_korean_fixture_produces_valid_output,
-        hypr_data::korean_1::SONIOX_JSON
-    );
-
-    fn word_count_from_fixture(json: &str) -> usize {
-        let responses: Vec<owhisper_interface::stream::StreamResponse> =
-            serde_json::from_str(json).unwrap();
-        let mut acc = TranscriptAccumulator::new();
-        let mut count = 0;
-        for r in &responses {
-            if let Some(input) = TranscriptInput::from_stream_response(r) {
-                if let Some(update) = acc.process(input) {
-                    count += update.new_final_words.len();
-                }
-            }
-        }
-        count += acc.flush().new_final_words.len();
-        count
-    }
-
-    /// Stability-based flush recovers Korean tail words that never get a
-    /// subsequent final, because they are seen in multiple consecutive partial
-    /// frames (consecutive_seen >= 2).
-    #[test]
-    fn stability_flush_recovers_soniox_korean_tail_words() {
-        let responses: Vec<owhisper_interface::stream::StreamResponse> =
-            serde_json::from_str(hypr_data::korean_1::SONIOX_JSON).unwrap();
-        let mut acc = TranscriptAccumulator::new();
-        for r in &responses {
-            if let Some(input) = TranscriptInput::from_stream_response(r) {
-                acc.process(input);
-            }
-        }
-
-        let tail_partials = acc.partial_stability();
-        assert!(
-            !tail_partials.is_empty(),
-            "Korean fixture must have tail partials"
-        );
-        assert!(
-            tail_partials.iter().all(|(_, seen)| *seen >= 2),
-            "all Korean tail partials must be stable (seen >= 2): {:?}",
-            tail_partials
-        );
-
-        let total = word_count_from_fixture(hypr_data::korean_1::SONIOX_JSON);
-        assert!(total > 0, "stability flush must recover Korean words");
-    }
-
-    #[test]
-    fn english_fixtures_produce_complete_output() {
-        for (label, json) in [
-            ("Deepgram English", hypr_data::english_1::DEEPGRAM_JSON),
-            ("Soniox English", hypr_data::english_1::SONIOX_JSON),
-        ] {
-            assert!(
-                word_count_from_fixture(json) > 0,
-                "{label}: must produce words"
-            );
-        }
-    }
-}
diff --git a/crates/transcript/src/accumulator/words.rs b/crates/transcript/src/accumulator/words.rs
deleted file mode 100644
index ac4f6d4345..0000000000
--- a/crates/transcript/src/accumulator/words.rs
+++ /dev/null
@@ -1,598 +0,0 @@
-use owhisper_interface::stream::Word;
-
-use crate::id::IdGenerator;
-use crate::types::{PartialWord, RawWord, SpeakerHint, TranscriptWord};
-
-// ── Partial stability tracking ────────────────────────────────────────────────
-
-/// A partial word together with how many consecutive partial responses have
-/// confirmed it at the same start time and with the same text.
-///
-/// The `consecutive_seen` counter is the primary input to
-/// Used by `channel::ChannelState` to track stability of partial words.
-#[derive(Debug, Clone)]
-pub(crate) struct PartialEntry {
-    pub(crate) word: RawWord,
-    pub(crate) consecutive_seen: u32,
-}
-
-// ── Assembly ──────────────────────────────────────────────────────────────────
-
-/// Assemble raw ASR tokens into merged `RawWord`s.
-///
-/// The transcript string is the **sole oracle** for word boundaries within a
-/// single response. `spacing_from_transcript` aligns each token to the
-/// transcript; a space prefix means "new word", no space means "same word."
-/// Adjacent tokens without a space prefix are unconditionally merged —
-/// no timing heuristics.
-pub(crate) fn assemble(raw: &[Word], transcript: &str, channel: i32) -> Vec<RawWord> {
-    let spaced = spacing_from_transcript(raw, transcript);
-    let mut result: Vec<RawWord> = Vec::new();
-
-    for (w, text) in raw.iter().zip(&spaced) {
-        let start_ms = (w.start * 1000.0).round() as i64;
-        let end_ms = (w.end * 1000.0).round() as i64;
-
-        let should_merge = !text.starts_with(' ') && result.last().is_some();
-
-        if should_merge {
-            let last = result.last_mut().unwrap();
-            last.text.push_str(text);
-            last.end_ms = end_ms;
-            if last.speaker.is_none() {
-                last.speaker = w.speaker;
-            }
-        } else {
-            result.push(RawWord {
-                text: text.clone(),
-                start_ms,
-                end_ms,
-                channel,
-                speaker: w.speaker,
-            });
-        }
-    }
-
-    result
-}
-
-/// Align each token to the transcript string and recover its spacing.
-///
-/// The transcript is the oracle: if a token is found in the transcript, the
-/// whitespace between the previous match and this one is prepended verbatim.
-/// If a token cannot be found (ASR/transcript mismatch), a space is forced
-/// so it becomes a separate word — "unknown = word boundary."
-fn spacing_from_transcript(raw: &[Word], transcript: &str) -> Vec<String> {
-    let mut result = Vec::with_capacity(raw.len());
-    let mut pos = 0;
-
-    for w in raw {
-        let text = w.punctuated_word.as_deref().unwrap_or(&w.word);
-        let trimmed = text.trim();
-
-        if trimmed.is_empty() {
-            result.push(text.to_string());
-            continue;
-        }
-
-        match transcript[pos..].find(trimmed) {
-            Some(found) => {
-                let abs = pos + found;
-                result.push(format!("{}{trimmed}", &transcript[pos..abs]));
-                pos = abs + trimmed.len();
-            }
-            None => {
-                let mut fallback = text.to_string();
-                if !fallback.starts_with(' ') {
-                    fallback.insert(0, ' ');
-                }
-                result.push(fallback);
-            }
-        }
-    }
-
-    result
-}
-
-// ── Pipeline stages ───────────────────────────────────────────────────────────
-
-/// Drop words already covered by the watermark (deduplication).
-pub(super) fn dedup(words: Vec<RawWord>, watermark: i64) -> Vec<RawWord> {
-    words
-        .into_iter()
-        .skip_while(|w| w.end_ms <= watermark)
-        .collect()
-}
-
-/// Cross-response word boundary handling — the one place where a timing
-/// heuristic is unavoidable, because no transcript spans both responses.
-///
-/// Holds back the last word of each finalized batch so it can be merged
-/// with the first word of the next batch if the provider split a word
-/// across responses (common with Korean particles, contractions, etc.).
-pub(super) fn stitch(
-    held: Option<RawWord>,
-    mut words: Vec<RawWord>,
-) -> (Vec<RawWord>, Option<RawWord>) {
-    if words.is_empty() {
-        return (held.into_iter().collect(), None);
-    }
-
-    if let Some(h) = held {
-        if should_stitch(&h, &words[0]) {
-            words[0] = merge_words(h, words[0].clone());
-        } else {
-            words.insert(0, h);
-        }
-    }
-
-    let new_held = words.pop();
-    (words, new_held)
-}
-
-/// Replace the time range covered by `incoming` within `existing`.
-///
-/// Kept as a standalone tested function; production code uses
-/// [`splice_partials`] which adds stability-counter tracking.
-#[allow(dead_code)]
-pub(super) fn splice(existing: &[RawWord], incoming: Vec<RawWord>) -> Vec<RawWord> {
-    let first_start = incoming.first().map_or(0, |w| w.start_ms);
-    let last_end = incoming.last().map_or(0, |w| w.end_ms);
-
-    existing
-        .iter()
-        .filter(|w| w.end_ms <= first_start)
-        .cloned()
-        .chain(incoming)
-        .chain(existing.iter().filter(|w| w.start_ms >= last_end).cloned())
-        .collect()
-}
-
-/// Remove partials that overlap with the finalized time range.
-///
-/// Kept as a standalone tested function; production code uses
-/// [`strip_overlap_entries`] which operates on [`PartialEntry`].
-#[allow(dead_code)]
-pub(super) fn strip_overlap(partials: Vec<RawWord>, final_end: i64) -> Vec<RawWord> {
-    partials
-        .into_iter()
-        .filter(|w| w.start_ms > final_end)
-        .collect()
-}
-
-/// Splice incoming words into the partial entries list, updating stability
-/// counters for unchanged words and resetting them for new/changed words.
-///
-/// A partial is "the same" if its `start_ms` and `text` match an existing
-/// entry; in that case the `consecutive_seen` counter is incremented.
-/// New or changed words start at 1.
-pub(super) fn splice_partials(
-    existing: &[PartialEntry],
-    incoming: Vec<RawWord>,
-) -> Vec<PartialEntry> {
-    if incoming.is_empty() {
-        return existing.to_vec();
-    }
-
-    let first_start = incoming.first().map_or(0, |w| w.start_ms);
-    let last_end = incoming.last().map_or(0, |w| w.end_ms);
-
-    let before = existing
-        .iter()
-        .filter(|e| e.word.end_ms <= first_start)
-        .cloned();
-    let after = existing
-        .iter()
-        .filter(|e| e.word.start_ms >= last_end)
-        .cloned();
-
-    let middle = incoming.into_iter().map(|word| {
-        let consecutive_seen = existing
-            .iter()
-            .find(|e| e.word.start_ms == word.start_ms && e.word.text == word.text)
-            .map_or(1, |e| e.consecutive_seen + 1);
-        PartialEntry {
-            word,
-            consecutive_seen,
-        }
-    });
-
-    before.chain(middle).chain(after).collect()
-}
-
-/// Remove partial entries whose start time falls within the finalized range.
-pub(super) fn strip_overlap_entries(
-    entries: Vec<PartialEntry>,
-    final_end: i64,
-) -> Vec<PartialEntry> {
-    entries
-        .into_iter()
-        .filter(|e| e.word.start_ms > final_end)
-        .collect()
-}
-
-// ── Word-level transforms ─────────────────────────────────────────────────────
-
-pub(super) fn ensure_space_prefix_raw(w: &mut RawWord) {
-    if !w.text.starts_with(' ') {
-        w.text.insert(0, ' ');
-    }
-}
-
-pub(crate) fn ensure_space_prefix_partial(w: &mut PartialWord) {
-    if !w.text.starts_with(' ') {
-        w.text.insert(0, ' ');
-    }
-}
-
-fn should_stitch(tail: &RawWord, head: &RawWord) -> bool {
-    !head.text.starts_with(' ') && (head.start_ms - tail.end_ms) <= 300
-}
-
-fn merge_words(mut left: RawWord, right: RawWord) -> RawWord {
-    left.text.push_str(&right.text);
-    left.end_ms = right.end_ms;
-    if left.speaker.is_none() {
-        left.speaker = right.speaker;
-    }
-    left
-}
-
-/// Convert finalized `RawWord`s into `TranscriptWord`s and `SpeakerHint`s.
-///
-/// IDs are generated by `id_gen`, ensuring space prefixes, and extracting
-/// speaker associations.
-pub(super) fn finalize_words(
-    mut words: Vec<RawWord>,
-    id_gen: &mut dyn IdGenerator,
-) -> (Vec<TranscriptWord>, Vec<SpeakerHint>) {
-    words.iter_mut().for_each(ensure_space_prefix_raw);
-
-    let mut final_words = Vec::with_capacity(words.len());
-    let mut hints = Vec::new();
-
-    for w in words {
-        let id = id_gen.next_id();
-        let (word, hint) = w.to_final(id);
-        final_words.push(word);
-        if let Some(h) = hint {
-            hints.push(h);
-        }
-    }
-
-    (final_words, hints)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::id::SequentialIdGen;
-
-    fn raw_word(text: &str, start: f64, end: f64) -> Word {
-        Word {
-            word: text.to_string(),
-            start,
-            end,
-            confidence: 1.0,
-            speaker: None,
-            punctuated_word: Some(text.to_string()),
-            language: None,
-        }
-    }
-
-    fn word(text: &str, start_ms: i64, end_ms: i64) -> RawWord {
-        RawWord {
-            text: text.to_string(),
-            start_ms,
-            end_ms,
-            channel: 0,
-            speaker: None,
-        }
-    }
-
-    fn entry(text: &str, start_ms: i64, end_ms: i64, seen: u32) -> PartialEntry {
-        PartialEntry {
-            word: word(text, start_ms, end_ms),
-            consecutive_seen: seen,
-        }
-    }
-
-    // ── spacing_from_transcript ──────────────────────────────────────────
-
-    #[test]
-    fn spacing_recovered_from_transcript() {
-        let raw = vec![raw_word("Hello", 0.0, 0.5), raw_word("world", 0.6, 1.0)];
-        let spaced = spacing_from_transcript(&raw, " Hello world");
-        assert_eq!(spaced, [" Hello", " world"]);
-    }
-
-    #[test]
-    fn spacing_forces_word_boundary_on_unfound_token() {
-        let raw = vec![raw_word("Hello", 0.0, 0.5)];
-        let spaced = spacing_from_transcript(&raw, "completely different");
-        assert_eq!(spaced, [" Hello"]);
-    }
-
-    #[test]
-    fn spacing_preserves_no_space_at_transcript_start() {
-        let raw = vec![raw_word("기", 0.0, 0.1), raw_word("간", 0.2, 0.3)];
-        let spaced = spacing_from_transcript(&raw, "기간");
-        assert_eq!(spaced, ["기", "간"]);
-    }
-
-    // ── assemble ─────────────────────────────────────────────────────────
-
-    #[test]
-    fn assemble_merges_attached_punctuation() {
-        let raw = vec![raw_word(" Hello", 0.0, 0.5), raw_word("'s", 0.51, 0.6)];
-        let words = assemble(&raw, " Hello's", 0);
-        assert_eq!(words.len(), 1);
-        assert_eq!(words[0].text, " Hello's");
-        assert_eq!(words[0].end_ms, 600);
-    }
-
-    #[test]
-    fn assemble_does_not_merge_spaced_tokens() {
-        let raw = vec![raw_word(" Hello", 0.0, 0.5), raw_word(" world", 0.51, 1.0)];
-        let words = assemble(&raw, " Hello world", 0);
-        assert_eq!(words.len(), 2);
-    }
-
-    #[test]
-    fn assemble_separates_unfound_tokens() {
-        let raw = vec![raw_word("Hello", 0.0, 0.5), raw_word("world", 0.51, 0.6)];
-        let words = assemble(&raw, "completely different text", 0);
-        assert_eq!(words.len(), 2);
-        assert!(words[0].text.starts_with(' '));
-        assert!(words[1].text.starts_with(' '));
-    }
-
-    #[test]
-    fn assemble_merges_cjk_syllables_with_large_gap() {
-        let raw = vec![
-            raw_word("있는", 0.0, 0.3),
-            raw_word("데", 0.54, 0.66),
-            raw_word(",", 0.84, 0.9),
-        ];
-        let words = assemble(&raw, " 있는데,", 0);
-        assert_eq!(
-            words.len(),
-            1,
-            "syllables in same CJK word must merge: {words:?}"
-        );
-        assert_eq!(words[0].text, " 있는데,");
-        assert_eq!(words[0].end_ms, 900);
-    }
-
-    #[test]
-    fn assemble_splits_cjk_words_at_transcript_space_boundary() {
-        let raw = vec![
-            raw_word("있는", 0.0, 0.3),
-            raw_word("데", 0.54, 0.66),
-            raw_word("학습", 1.0, 1.3),
-            raw_word("과", 1.54, 1.66),
-        ];
-        let words = assemble(&raw, " 있는데 학습과", 0);
-        assert_eq!(
-            words.len(),
-            2,
-            "space in transcript must split words: {words:?}"
-        );
-        assert_eq!(words[0].text, " 있는데");
-        assert_eq!(words[1].text, " 학습과");
-    }
-
-    // ── dedup ────────────────────────────────────────────────────────────
-
-    #[test]
-    fn dedup_drops_words_at_or_before_watermark() {
-        let words = vec![
-            word(" a", 0, 100),
-            word(" b", 100, 200),
-            word(" c", 200, 300),
-        ];
-        let result = dedup(words, 200);
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].text, " c");
-    }
-
-    #[test]
-    fn dedup_keeps_all_when_watermark_is_zero() {
-        let words = vec![word(" a", 0, 100), word(" b", 100, 200)];
-        let result = dedup(words, 0);
-        assert_eq!(result.len(), 2);
-    }
-
-    #[test]
-    fn dedup_returns_empty_when_all_covered() {
-        let words = vec![word(" a", 0, 100), word(" b", 100, 200)];
-        let result = dedup(words, 200);
-        assert!(result.is_empty());
-    }
-
-    // ── stitch ───────────────────────────────────────────────────────────
-
-    #[test]
-    fn stitch_no_held_holds_last() {
-        let ws = vec![word(" Hello", 0, 500), word(" world", 600, 1000)];
-        let (emitted, held) = stitch(None, ws);
-        assert_eq!(emitted.len(), 1);
-        assert_eq!(emitted[0].text, " Hello");
-        assert_eq!(held.unwrap().text, " world");
-    }
-
-    #[test]
-    fn stitch_merges_spaceless_adjacent_head() {
-        let held = word(" Hello", 0, 500);
-        let ws = vec![word("'s", 550, 700)];
-        let (emitted, held) = stitch(Some(held), ws);
-        assert!(emitted.is_empty());
-        assert_eq!(held.unwrap().text, " Hello's");
-    }
-
-    #[test]
-    fn stitch_separates_spaced_head() {
-        let held = word(" Hello", 0, 500);
-        let ws = vec![word(" world", 600, 1000)];
-        let (emitted, held) = stitch(Some(held), ws);
-        assert_eq!(emitted.len(), 1);
-        assert_eq!(emitted[0].text, " Hello");
-        assert_eq!(held.unwrap().text, " world");
-    }
-
-    #[test]
-    fn stitch_separates_distant_spaceless_head() {
-        let held = word(" Hello", 0, 500);
-        let ws = vec![word("world", 1000, 1500)];
-        let (emitted, held) = stitch(Some(held), ws);
-        assert_eq!(emitted.len(), 1);
-        assert_eq!(emitted[0].text, " Hello");
-        assert_eq!(held.unwrap().text, "world");
-    }
-
-    #[test]
-    fn stitch_empty_batch_releases_held() {
-        let held = word(" Hello", 0, 500);
-        let (emitted, held) = stitch(Some(held), vec![]);
-        assert_eq!(emitted.len(), 1);
-        assert!(held.is_none());
-    }
-
-    #[test]
-    fn stitch_single_word_batch_yields_no_emission() {
-        let ws = vec![word(" Hello", 0, 500)];
-        let (emitted, held) = stitch(None, ws);
-        assert!(emitted.is_empty());
-        assert_eq!(held.unwrap().text, " Hello");
-    }
-
-    // ── splice ───────────────────────────────────────────────────────────
-
-    #[test]
-    fn splice_replaces_overlapping_range() {
-        let existing = vec![
-            word(" a", 0, 100),
-            word(" b", 100, 200),
-            word(" c", 300, 400),
-        ];
-        let incoming = vec![word(" B", 100, 200), word(" new", 200, 300)];
-        let result = splice(&existing, incoming);
-        assert_eq!(
-            result.iter().map(|w| &w.text[..]).collect::<Vec<_>>(),
-            [" a", " B", " new", " c"]
-        );
-    }
-
-    #[test]
-    fn splice_appends_when_no_overlap() {
-        let existing = vec![word(" a", 0, 100)];
-        let incoming = vec![word(" b", 200, 300)];
-        let result = splice(&existing, incoming);
-        assert_eq!(result.len(), 2);
-    }
-
-    #[test]
-    fn splice_full_replacement() {
-        let existing = vec![word(" a", 0, 100), word(" b", 100, 200)];
-        let incoming = vec![
-            word(" x", 0, 100),
-            word(" y", 100, 200),
-            word(" z", 200, 300),
-        ];
-        let result = splice(&existing, incoming);
-        assert_eq!(
-            result.iter().map(|w| &w.text[..]).collect::<Vec<_>>(),
-            [" x", " y", " z"]
-        );
-    }
-
-    // ── strip_overlap ────────────────────────────────────────────────────
-
-    #[test]
-    fn strip_overlap_removes_covered_partials() {
-        let partials = vec![
-            word(" a", 0, 100),
-            word(" b", 100, 200),
-            word(" c", 300, 400),
-        ];
-        let result = strip_overlap(partials, 200);
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].text, " c");
-    }
-
-    #[test]
-    fn strip_overlap_keeps_all_beyond_range() {
-        let partials = vec![word(" a", 300, 400), word(" b", 400, 500)];
-        let result = strip_overlap(partials, 200);
-        assert_eq!(result.len(), 2);
-    }
-
-    // ── splice_partials ──────────────────────────────────────────────────
-
-    #[test]
-    fn splice_partials_increments_counter_for_stable_word() {
-        let existing = vec![entry(" Hello", 0, 500, 2)];
-        let incoming = vec![word(" Hello", 0, 500)];
-        let result = splice_partials(&existing, incoming);
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].consecutive_seen, 3);
-    }
-
-    #[test]
-    fn splice_partials_resets_counter_for_changed_text() {
-        let existing = vec![entry(" Helo", 0, 500, 5)];
-        let incoming = vec![word(" Hello", 0, 500)];
-        let result = splice_partials(&existing, incoming);
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].consecutive_seen, 1);
-    }
-
-    #[test]
-    fn splice_partials_starts_at_one_for_new_word() {
-        let incoming = vec![word(" new", 0, 500)];
-        let result = splice_partials(&[], incoming);
-        assert_eq!(result.len(), 1);
-        assert_eq!(result[0].consecutive_seen, 1);
-    }
-
-    #[test]
-    fn splice_partials_preserves_before_and_after() {
-        let existing = vec![entry(" a", 0, 100, 3), entry(" c", 300, 400, 2)];
-        let incoming = vec![word(" b", 100, 300)];
-        let result = splice_partials(&existing, incoming);
-        assert_eq!(
-            result
-                .iter()
-                .map(|e| e.word.text.as_str())
-                .collect::<Vec<_>>(),
-            [" a", " b", " c"]
-        );
-        assert_eq!(result[0].consecutive_seen, 3);
-        assert_eq!(result[1].consecutive_seen, 1);
-        assert_eq!(result[2].consecutive_seen, 2);
-    }
-
-    // ── finalize_words ───────────────────────────────────────────────────
-
-    #[test]
-    fn finalize_words_assigns_ids_and_space_prefix() {
-        let words = vec![word("hello", 0, 500), word(" world", 500, 1000)];
-        let mut id_gen = SequentialIdGen::new();
-        let (final_words, hints): (Vec<TranscriptWord>, Vec<SpeakerHint>) =
-            finalize_words(words, &mut id_gen);
-        assert_eq!(final_words.len(), 2);
-        assert!(final_words.iter().all(|w| !w.id.is_empty()));
-        assert!(final_words.iter().all(|w| w.text.starts_with(' ')));
-        assert!(hints.is_empty());
-    }
-
-    #[test]
-    fn finalize_words_uses_sequential_ids() {
-        let words = vec![word(" a", 0, 100), word(" b", 100, 200)];
-        let mut id_gen = SequentialIdGen::new();
-        let (final_words, _): (Vec<TranscriptWord>, Vec<SpeakerHint>) =
-            finalize_words(words, &mut id_gen);
-        assert_eq!(final_words[0].id, "0");
-        assert_eq!(final_words[1].id, "1");
-    }
-}
diff --git a/crates/transcript/src/id.rs b/crates/transcript/src/id.rs
deleted file mode 100644
index 9fc9fa7668..0000000000
--- a/crates/transcript/src/id.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-pub trait IdGenerator: Send + Sync {
-    fn next_id(&mut self) -> String;
-}
-
-pub struct UuidIdGen;
-
-impl Default for UuidIdGen {
-    fn default() -> Self {
-        Self
-    }
-}
-
-impl IdGenerator for UuidIdGen {
-    fn next_id(&mut self) -> String {
-        uuid::Uuid::new_v4().to_string()
-    }
-}
-
-/// Deterministic sequential ID generator for tests and golden-file snapshots
-/// where stable, reproducible word IDs are required.
-pub struct SequentialIdGen(u64);
-
-impl SequentialIdGen {
-    pub fn new() -> Self {
-        Self(0)
-    }
-}
-
-impl Default for SequentialIdGen {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl IdGenerator for SequentialIdGen {
-    fn next_id(&mut self) -> String {
-        let id = self.0;
-        self.0 += 1;
-        id.to_string()
-    }
-}
diff --git a/crates/transcript/src/input.rs b/crates/transcript/src/input.rs
deleted file mode 100644
index 7ca4b8955f..0000000000
--- a/crates/transcript/src/input.rs
+++ /dev/null
@@ -1,67 +0,0 @@
-use owhisper_interface::stream::StreamResponse;
-
-use crate::accumulator::words::assemble;
-use crate::types::RawWord;
-
-/// Provider-agnostic input to the transcript accumulator.
-///
-/// Convert your provider-specific event type into `TranscriptInput` before
-/// feeding it to [`crate::accumulator::TranscriptAccumulator::process`] or
-/// [`crate::view::TranscriptView::process`]. This keeps the accumulator core
-/// free of provider dependencies and makes it easy to feed corrections or
-/// synthetic events without going through a wire-format struct.
-///
-/// For the `owhisper_interface` wire format use
-/// [`TranscriptInput::from_stream_response`].
-#[derive(Debug, Clone)]
-pub enum TranscriptInput {
-    Final { words: Vec<RawWord> },
-    Partial { words: Vec<RawWord> },
-    Correction { words: Vec<RawWord> },
-}
-
-impl TranscriptInput {
-    /// Convert an `owhisper_interface` streaming response into a
-    /// `TranscriptInput`, running the transcript-as-oracle word assembly.
-    ///
-    /// Returns `None` for non-transcript variants (metadata, errors, …) and
-    /// for responses whose word list and transcript string are both empty.
-    pub fn from_stream_response(response: &StreamResponse) -> Option<Self> {
-        let (is_final, channel, channel_index, metadata) = match response {
-            StreamResponse::TranscriptResponse {
-                is_final,
-                channel,
-                channel_index,
-                metadata,
-                ..
-            } => (*is_final, channel, channel_index, metadata),
-            _ => return None,
-        };
-
-        let is_correction = metadata
-            .extra
-            .as_ref()
-            .and_then(|e| e.get("cloud_corrected"))
-            .and_then(|v| v.as_bool())
-            .unwrap_or(false);
-
-        let alt = channel.alternatives.first()?;
-        if alt.words.is_empty() && alt.transcript.is_empty() {
-            return None;
-        }
-
-        let ch = channel_index.first().copied().unwrap_or(0);
-        let words = assemble(&alt.words, &alt.transcript, ch);
-        if words.is_empty() {
-            return None;
-        }
-
-        Some(if is_correction {
-            Self::Correction { words }
-        } else if is_final {
-            Self::Final { words }
-        } else {
-            Self::Partial { words }
-        })
-    }
-}
diff --git a/crates/transcript/src/lib.rs b/crates/transcript/src/lib.rs
index 84bdb70321..681fda3c5b 100644
--- a/crates/transcript/src/lib.rs
+++ b/crates/transcript/src/lib.rs
@@ -1,15 +1,7 @@
-pub mod accumulator;
-pub mod id;
-pub mod input;
-pub mod postprocess;
-pub mod types;
-pub mod view;
+mod accumulator;
+mod processor;
+mod types;
+mod words;
 
-pub use accumulator::TranscriptAccumulator;
-pub use id::{IdGenerator, SequentialIdGen, UuidIdGen};
-pub use input::TranscriptInput;
-pub use postprocess::{BoxFuture, PostProcessError, PostProcessUpdate, PostProcessor};
-pub use types::{
-    PartialWord, RawWord, SpeakerHint, TranscriptFrame, TranscriptUpdate, TranscriptWord,
-};
-pub use view::{PipelineDebugFrame, ProcessOutcome, TranscriptView};
+pub use processor::TranscriptProcessor;
+pub use types::{FinalizedWord, PartialWord, RawWord, SpeakerHint, TranscriptDelta, WordState};
diff --git a/crates/transcript/src/postprocess/mod.rs b/crates/transcript/src/postprocess/mod.rs
deleted file mode 100644
index 787672e948..0000000000
--- a/crates/transcript/src/postprocess/mod.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-use std::future::Future;
-use std::pin::Pin;
-
-use crate::types::TranscriptWord;
-
-pub type PostProcessError = Box<dyn std::error::Error + Send + Sync + 'static>;
-
-pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;
-
-/// A snapshot of what changed as a result of one postprocessing pass.
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
-pub struct PostProcessUpdate {
-    /// The updated words. IDs are identical to the originals so the
-    /// frontend can match them to existing displayed words.
-    pub updated: Vec<TranscriptWord>,
-    /// IDs of the words that were replaced, one-to-one with `updated`.
-    pub replaced_ids: Vec<String>,
-}
-
-/// Async postprocessor contract for finalized transcript words.
-///
-/// An implementation receives a batch of finalized [`TranscriptWord`]s and
-/// returns a replacement slice of the **same length** with updated text.
-/// Word IDs must be preserved — the frontend relies on them to match
-/// updates to already-displayed words.
-///
-/// The caller decides which words to feed in (all finals, last N, new since
-/// last run) and is responsible for scheduling. The recommended pattern:
-///
-/// ```ignore
-/// let words = view.frame().final_words.clone();  // snapshot
-/// let result = processor.process(&words).await?; // async, may take 1-2s
-/// let update = view.apply_postprocess(result);   // apply by ID match
-/// ```
-///
-/// Staleness is handled automatically: if the session resets or words change
-/// between snapshot and apply, unknown IDs are silently ignored.
-///
-/// # Object safety
-///
-/// The trait is object-safe via the explicit `BoxFuture` return type. Use
-/// `dyn PostProcessor` when you need dynamic dispatch.
-pub trait PostProcessor: Send + Sync {
-    fn process<'a>(
-        &'a self,
-        words: &'a [TranscriptWord],
-    ) -> BoxFuture<'a, Result<Vec<TranscriptWord>, PostProcessError>>;
-}
diff --git a/crates/transcript/src/processor.rs b/crates/transcript/src/processor.rs
new file mode 100644
index 0000000000..d20b4a786f
--- /dev/null
+++ b/crates/transcript/src/processor.rs
@@ -0,0 +1,272 @@
+use std::collections::{BTreeMap, HashMap};
+
+use owhisper_interface::{batch::Response as BatchResponse, stream::StreamResponse};
+
+use super::accumulator::ChannelState;
+use super::types::{FinalizedWord, PartialWord, TranscriptDelta, WordState};
+use super::words::{assemble, assemble_batch, finalize_words};
+
+/// Stateful processor that converts raw `StreamResponse`s into
+/// `TranscriptDelta`s and manages correction jobs from any source.
+///
+/// # Correction sources
+///
+/// All correction flows follow the same lifecycle:
+///
+/// 1. Words are finalized (with state `Pending` or `Final`)
+/// 2. A correction source processes them asynchronously
+/// 3. Correction resolves: pending words are replaced with corrected finals
+/// 4. On timeout: pending words become final with original text
+///
+/// The processor supports two integration patterns:
+///
+/// - **Inline** (cactus cloud handoff): the streaming protocol itself carries
+///   handoff/correction metadata. Handled automatically inside `process()`.
+///
+/// - **External** (LLM postprocessor, future sources): the caller finalizes
+///   words via `process()`, then calls `submit_correction` / `apply_correction`
+///   to manage the pending→final lifecycle.
+pub struct TranscriptProcessor {
+    channels: BTreeMap<i32, ChannelState>,
+    pending_corrections: HashMap<u64, Vec<String>>,
+    next_job_id: u64,
+}
+
+impl TranscriptProcessor {
+    pub fn new() -> Self {
+        Self {
+            channels: BTreeMap::new(),
+            pending_corrections: HashMap::new(),
+            next_job_id: 1,
+        }
+    }
+
+    /// Process one streaming response. Returns `None` for non-transcript
+    /// responses or responses with no words.
+    ///
+    /// Cactus cloud handoff metadata (`cloud_handoff`, `cloud_corrected`) is
+    /// handled inline: handoff words are emitted as `Pending`, corrections
+    /// resolve the pending job and emit `replaced_ids`.
+    pub fn process(&mut self, response: &StreamResponse) -> Option<TranscriptDelta> {
+        let (is_final, channel, channel_index, metadata) = match response {
+            StreamResponse::TranscriptResponse {
+                is_final,
+                channel,
+                channel_index,
+                metadata,
+                ..
+            } => (*is_final, channel, channel_index, metadata),
+            _ => return None,
+        };
+
+        let alt = channel.alternatives.first()?;
+        if alt.words.is_empty() && alt.transcript.is_empty() {
+            return None;
+        }
+
+        let ch = channel_index.first().copied().unwrap_or(0) as i32;
+        let raw_words = assemble(&alt.words, &alt.transcript, ch);
+        if raw_words.is_empty() {
+            return None;
+        }
+
+        let extra = metadata.extra.as_ref();
+        let get_bool = |key: &str| -> bool {
+            extra
+                .and_then(|e| e.get(key))
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false)
+        };
+        let get_u64 = |key: &str| -> u64 {
+            extra
+                .and_then(|e| e.get(key))
+                .and_then(|v| v.as_u64())
+                .unwrap_or(0)
+        };
+
+        let is_cloud_corrected = get_bool("cloud_corrected");
+        let is_cloud_handoff = get_bool("cloud_handoff");
+        let cloud_job_id = get_u64("cloud_job_id");
+
+        let channel_state = self.channels.entry(ch).or_insert_with(ChannelState::new);
+
+        if is_final {
+            let word_state = if is_cloud_handoff && cloud_job_id != 0 {
+                WordState::Pending
+            } else {
+                WordState::Final
+            };
+
+            let (new_words, hints) = channel_state.apply_final(raw_words, word_state);
+
+            let replaced_ids = if is_cloud_corrected && cloud_job_id != 0 {
+                self.resolve_job(cloud_job_id)
+            } else {
+                vec![]
+            };
+
+            if is_cloud_handoff && cloud_job_id != 0 {
+                let ids: Vec<String> = new_words.iter().map(|w| w.id.clone()).collect();
+                self.register_job(cloud_job_id, ids);
+            }
+
+            let partials = self.all_partials();
+
+            if new_words.is_empty() && replaced_ids.is_empty() {
+                return None;
+            }
+
+            Some(TranscriptDelta {
+                new_words,
+                hints,
+                replaced_ids,
+                partials,
+            })
+        } else {
+            channel_state.apply_partial(raw_words);
+
+            Some(TranscriptDelta {
+                new_words: vec![],
+                hints: vec![],
+                replaced_ids: vec![],
+                partials: self.all_partials(),
+            })
+        }
+    }
+
+    // ── Generic correction API ──────────────────────────────────────────────
+
+    /// Submit already-emitted `Final` words for asynchronous correction.
+    ///
+    /// Returns `(job_id, delta)`. The delta re-emits the words with
+    /// `Pending` state and sets `replaced_ids` to their current IDs, so the
+    /// frontend transitions them from Final→Pending.
+    ///
+    /// The caller should spawn the correction task and later call
+    /// `apply_correction` with the same `job_id`.
+    pub fn submit_correction(&mut self, words: Vec<FinalizedWord>) -> (u64, TranscriptDelta) {
+        let job_id = self.next_job_id();
+        let replaced_ids: Vec<String> = words.iter().map(|w| w.id.clone()).collect();
+
+        self.register_job(job_id, replaced_ids.clone());
+
+        let pending_words: Vec<FinalizedWord> = words
+            .into_iter()
+            .map(|w| FinalizedWord {
+                state: WordState::Pending,
+                ..w
+            })
+            .collect();
+
+        let delta = TranscriptDelta {
+            new_words: pending_words,
+            hints: vec![],
+            replaced_ids,
+            partials: self.all_partials(),
+        };
+
+        (job_id, delta)
+    }
+
+    /// Resolve a pending correction job with corrected words.
+    ///
+    /// `corrected_words` should have `state: Final`. Their IDs can differ
+    /// from the originals (the correction may change word boundaries).
+    /// `replaced_ids` in the returned delta contains the original pending IDs.
+    pub fn apply_correction(
+        &mut self,
+        job_id: u64,
+        corrected_words: Vec<FinalizedWord>,
+    ) -> TranscriptDelta {
+        let replaced_ids = self.resolve_job(job_id);
+
+        TranscriptDelta {
+            new_words: corrected_words,
+            hints: vec![],
+            replaced_ids,
+            partials: self.all_partials(),
+        }
+    }
+
+    /// Drain all remaining state at session end.
+    pub fn flush(&mut self) -> TranscriptDelta {
+        let mut new_words = vec![];
+        let mut hints = vec![];
+
+        for state in self.channels.values_mut() {
+            let (words, word_hints) = state.drain();
+            new_words.extend(words);
+            hints.extend(word_hints);
+        }
+
+        self.channels.clear();
+        self.pending_corrections.clear();
+
+        TranscriptDelta {
+            new_words,
+            hints,
+            replaced_ids: vec![],
+            partials: vec![],
+        }
+    }
+
+    /// Convert a complete batch response into a `TranscriptDelta`.
+    ///
+    /// Stateless — batch responses are already final and don't need the
+    /// streaming state (watermark, held word, etc.) used by `process()`.
+    pub fn process_batch_response(response: &BatchResponse) -> TranscriptDelta {
+        let mut new_words = Vec::new();
+        let mut hints = Vec::new();
+
+        for (channel_idx, channel) in response.results.channels.iter().enumerate() {
+            let Some(alt) = channel.alternatives.first() else {
+                continue;
+            };
+            if alt.words.is_empty() {
+                continue;
+            }
+
+            let ch = channel_idx as i32;
+            let raw = assemble_batch(&alt.words, &alt.transcript, ch);
+            let (channel_words, channel_hints) = finalize_words(raw, WordState::Final);
+            new_words.extend(channel_words);
+            hints.extend(channel_hints);
+        }
+
+        TranscriptDelta {
+            new_words,
+            hints,
+            replaced_ids: vec![],
+            partials: vec![],
+        }
+    }
+
+    // ── Internal ────────────────────────────────────────────────────────────
+
+    fn register_job(&mut self, job_id: u64, word_ids: Vec<String>) {
+        self.pending_corrections.insert(job_id, word_ids);
+    }
+
+    fn resolve_job(&mut self, job_id: u64) -> Vec<String> {
+        self.pending_corrections.remove(&job_id).unwrap_or_default()
+    }
+
+    fn next_job_id(&mut self) -> u64 {
+        let id = self.next_job_id;
+        self.next_job_id += 1;
+        id
+    }
+
+    fn all_partials(&self) -> Vec<PartialWord> {
+        self.channels
+            .values()
+            .flat_map(|s| s.current_partials())
+            .collect()
+    }
+}
+
+impl Default for TranscriptProcessor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/crates/transcript/src/types.rs b/crates/transcript/src/types.rs
index 886f67132e..420d29025d 100644
--- a/crates/transcript/src/types.rs
+++ b/crates/transcript/src/types.rs
@@ -1,10 +1,11 @@
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
-pub struct TranscriptWord {
-    pub id: String,
+/// Pre-finalization word data from the ASR pipeline, before ID assignment.
+#[derive(Debug, Clone)]
+pub struct RawWord {
     pub text: String,
     pub start_ms: i64,
     pub end_ms: i64,
     pub channel: i32,
+    pub speaker: Option<i32>,
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
@@ -15,77 +16,60 @@ pub struct PartialWord {
     pub channel: i32,
 }
 
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
-pub struct SpeakerHint {
-    pub word_id: String,
-    pub speaker_index: i32,
+/// Whether a finalized word is stable or awaiting correction.
+///
+/// A word is `Pending` when it has been confirmed by the STT model but a
+/// correction source (cloud STT fallback, LLM postprocessor, etc.) is still
+/// processing it. The word has an ID and is persisted, but its text may be
+/// replaced when the correction resolves via `TranscriptDelta::replaced_ids`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize, specta::Type)]
+#[serde(rename_all = "snake_case")]
+pub enum WordState {
+    Final,
+    Pending,
 }
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
-pub struct TranscriptUpdate {
-    pub new_final_words: Vec<TranscriptWord>,
-    pub speaker_hints: Vec<SpeakerHint>,
-    /// Current partials across **all** channels — a global snapshot, not a
-    /// per-channel delta. When channel 0 finalizes, this field still includes
-    /// channel 1's in-progress words. Callers that only care about newly
-    /// finalized words can ignore this and call
-    /// [`crate::view::TranscriptView::frame`] for a complete frame snapshot.
-    pub partial_words: Vec<PartialWord>,
+pub struct FinalizedWord {
+    pub id: String,
+    pub text: String,
+    pub start_ms: i64,
+    pub end_ms: i64,
+    pub channel: i32,
+    pub state: WordState,
 }
 
-/// Complete snapshot of transcript state at a point in time.
-///
-/// This is the rendering contract: everything a UI layer needs to draw one
-/// frame, whether that UI is the terminal replay tool, the TypeScript
-/// frontend, or a test assertion. Produced by `TranscriptView::frame()`.
-#[derive(Debug, Clone, Default, serde::Serialize, serde::Deserialize, specta::Type)]
-pub struct TranscriptFrame {
-    pub final_words: Vec<TranscriptWord>,
-    pub partial_words: Vec<PartialWord>,
-    pub speaker_hints: Vec<SpeakerHint>,
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
+pub struct SpeakerHint {
+    pub word_id: String,
+    pub speaker_index: i32,
 }
 
-// ── Internal pipeline type ───────────────────────────────────────────────────
-
-/// Pre-finalization word data — the lingua franca of the accumulator pipeline.
+/// Delta emitted to the frontend after processing.
 ///
-/// Produced by [`crate::accumulator::words::assemble`] from raw ASR tokens and
-/// consumed by the pipeline stages (`dedup`, `stitch`, `splice`, …) before
-/// being promoted to [`TranscriptWord`] via `finalize_words`.
+/// The frontend should:
+/// 1. Remove words listed in `replaced_ids` from TinyBase
+/// 2. Persist `new_words` to TinyBase (honoring `state`)
+/// 3. Store `partials` in ephemeral Zustand state for rendering
 ///
-/// Also carried in [`crate::input::TranscriptInput`], so callers that
-/// construct synthetic inputs (tests, non-ASR sources) work with this type.
-#[derive(Debug, Clone)]
-pub struct RawWord {
-    pub text: String,
-    pub start_ms: i64,
-    pub end_ms: i64,
-    pub channel: i32,
-    pub speaker: Option<i32>,
+/// This shape handles all correction flows uniformly:
+/// - Normal finalization: `new_words` with `Final`, empty `replaced_ids`
+/// - Pending correction submitted: `new_words` with `Pending`, `replaced_ids`
+///   pointing at the same words' previous `Final` versions
+/// - Correction resolved: `new_words` with `Final` (corrected text),
+///   `replaced_ids` pointing at the `Pending` versions
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
+pub struct TranscriptDelta {
+    pub new_words: Vec<FinalizedWord>,
+    pub hints: Vec<SpeakerHint>,
+    /// IDs of words superseded by `new_words`. Empty for normal finalization.
+    pub replaced_ids: Vec<String>,
+    /// Current in-progress words across all channels. Global snapshot.
+    pub partials: Vec<PartialWord>,
 }
 
-impl RawWord {
-    pub fn to_final(self, id: String) -> (TranscriptWord, Option<SpeakerHint>) {
-        let hint = self.speaker.map(|speaker_index| SpeakerHint {
-            word_id: id.clone(),
-            speaker_index,
-        });
-        let word = TranscriptWord {
-            id,
-            text: self.text,
-            start_ms: self.start_ms,
-            end_ms: self.end_ms,
-            channel: self.channel,
-        };
-        (word, hint)
-    }
-
-    pub fn to_partial(&self) -> PartialWord {
-        PartialWord {
-            text: self.text.clone(),
-            start_ms: self.start_ms,
-            end_ms: self.end_ms,
-            channel: self.channel,
-        }
+impl TranscriptDelta {
+    pub fn is_empty(&self) -> bool {
+        self.new_words.is_empty() && self.replaced_ids.is_empty() && self.partials.is_empty()
     }
 }
diff --git a/crates/transcript/src/view.rs b/crates/transcript/src/view.rs
deleted file mode 100644
index d7310e4644..0000000000
--- a/crates/transcript/src/view.rs
+++ /dev/null
@@ -1,588 +0,0 @@
-use crate::accumulator::TranscriptAccumulator;
-use crate::id::{IdGenerator, UuidIdGen};
-use crate::input::TranscriptInput;
-use crate::postprocess::PostProcessUpdate;
-use crate::types::{RawWord, SpeakerHint, TranscriptFrame, TranscriptWord};
-
-/// Result of feeding one [`TranscriptInput`] into [`TranscriptView::process`].
-#[derive(Debug, Clone)]
-pub enum ProcessOutcome {
-    Unchanged,
-    Updated,
-    Corrected(PostProcessUpdate),
-}
-
-/// Debug snapshot of the accumulator pipeline state, intended for tooling and
-/// visualisation only. Not part of the stable rendering contract.
-#[derive(Debug, Clone, Default)]
-pub struct PipelineDebugFrame {
-    /// Each partial word currently in flight, paired with the number of
-    /// consecutive partial responses that have confirmed it unchanged.
-    /// Higher counts mean the word is more stable and closer to promotion.
-    pub partial_stability: Vec<(String, u32)>,
-    /// Number of postprocess batches applied via [`TranscriptView::apply_postprocess`]
-    /// since this view was created (or last reset).
-    pub postprocess_applied: usize,
-    /// The word currently held by the stitch stage, per channel.
-    /// Format: (channel_index, word_text).
-    pub held_words: Vec<(i32, String)>,
-    /// The dedup watermark (end_ms of the last finalized word) per channel.
-    /// Format: (channel_index, watermark_ms).
-    pub watermarks: Vec<(i32, i64)>,
-}
-
-/// Stateful driver that accumulates responses and exposes a complete
-/// [`TranscriptFrame`] snapshot on every update.
-///
-/// Use this when your renderer wants to read the full current state (e.g., a
-/// terminal UI or a test assertion) rather than handle deltas manually.
-/// For fine-grained delta control (e.g., a Tauri plugin that needs to persist
-/// only newly finalized words), use [`TranscriptAccumulator`] directly.
-pub struct TranscriptView {
-    acc: TranscriptAccumulator,
-    final_words: Vec<TranscriptWord>,
-    speaker_hints: Vec<SpeakerHint>,
-    postprocess_applied: usize,
-}
-
-impl TranscriptView {
-    pub fn new() -> Self {
-        Self::with_config(UuidIdGen)
-    }
-
-    pub fn with_config(id_gen: impl IdGenerator + 'static) -> Self {
-        Self {
-            acc: TranscriptAccumulator::with_config(id_gen),
-            final_words: Vec::new(),
-            speaker_hints: Vec::new(),
-            postprocess_applied: 0,
-        }
-    }
-
-    /// Feed one [`TranscriptInput`]. Returns a [`ProcessOutcome`] describing
-    /// what changed.
-    pub fn process(&mut self, input: TranscriptInput) -> ProcessOutcome {
-        if let TranscriptInput::Correction { words } = input {
-            return self.apply_correction(words);
-        }
-
-        match self.acc.process(input) {
-            Some(update) => {
-                self.final_words.extend(update.new_final_words);
-                self.speaker_hints.extend(update.speaker_hints);
-                ProcessOutcome::Updated
-            }
-            None => ProcessOutcome::Unchanged,
-        }
-    }
-
-    fn apply_correction(&mut self, correction_words: Vec<RawWord>) -> ProcessOutcome {
-        if correction_words.is_empty() {
-            return ProcessOutcome::Unchanged;
-        }
-
-        let corr_start = correction_words.iter().map(|w| w.start_ms).min().unwrap();
-        let corr_end = correction_words.iter().map(|w| w.end_ms).max().unwrap();
-        let corr_channel = correction_words[0].channel;
-
-        let matched_indices: Vec<usize> = self
-            .final_words
-            .iter()
-            .enumerate()
-            .filter(|(_, w)| {
-                w.channel == corr_channel && w.start_ms >= corr_start && w.end_ms <= corr_end
-            })
-            .map(|(i, _)| i)
-            .collect();
-
-        if matched_indices.is_empty() {
-            return ProcessOutcome::Unchanged;
-        }
-
-        let replaced_ids: Vec<String> = matched_indices
-            .iter()
-            .map(|&i| self.final_words[i].id.clone())
-            .collect();
-
-        let mut updated = Vec::new();
-
-        if matched_indices.len() == correction_words.len() {
-            for (&idx, cw) in matched_indices.iter().zip(correction_words.iter()) {
-                let existing = &mut self.final_words[idx];
-                existing.text = cw.text.clone();
-                existing.start_ms = cw.start_ms;
-                existing.end_ms = cw.end_ms;
-                updated.push(existing.clone());
-            }
-        } else {
-            let first_idx = matched_indices[0];
-            let remove_count = matched_indices.len();
-
-            let new_words: Vec<TranscriptWord> = correction_words
-                .into_iter()
-                .enumerate()
-                .map(|(i, cw)| {
-                    let id = if i < replaced_ids.len() {
-                        replaced_ids[i].clone()
-                    } else {
-                        uuid::Uuid::new_v4().to_string()
-                    };
-                    TranscriptWord {
-                        id,
-                        text: cw.text,
-                        start_ms: cw.start_ms,
-                        end_ms: cw.end_ms,
-                        channel: cw.channel,
-                    }
-                })
-                .collect();
-
-            updated = new_words.clone();
-            self.final_words
-                .splice(first_idx..first_idx + remove_count, new_words);
-        }
-
-        self.postprocess_applied += 1;
-
-        ProcessOutcome::Corrected(PostProcessUpdate {
-            updated,
-            replaced_ids,
-        })
-    }
-
-    /// Drain any held or partial words at session end.
-    ///
-    /// The held word is always promoted. Partials stable across multiple
-    /// consecutive frames are promoted; single-shot partials are dropped as noise.
-    pub fn flush(&mut self) {
-        let update = self.acc.flush();
-        self.final_words.extend(update.new_final_words);
-        self.speaker_hints.extend(update.speaker_hints);
-    }
-
-    /// Returns the complete snapshot needed to render the current transcript.
-    pub fn frame(&self) -> TranscriptFrame {
-        TranscriptFrame {
-            final_words: self.final_words.clone(),
-            partial_words: self.acc.all_partials(),
-            speaker_hints: self.speaker_hints.clone(),
-        }
-    }
-
-    /// Returns a debug snapshot of internal pipeline state.
-    ///
-    /// Intended for tooling and visualisation; not part of the stable
-    /// rendering contract and may change freely.
-    pub fn pipeline_debug(&self) -> PipelineDebugFrame {
-        PipelineDebugFrame {
-            partial_stability: self.acc.partial_stability(),
-            postprocess_applied: self.postprocess_applied,
-            held_words: self.acc.held_words(),
-            watermarks: self.acc.watermarks(),
-        }
-    }
-
-    /// Apply a batch of postprocessed words back into the transcript.
-    ///
-    /// Each word is matched to an existing final word by `id`. Words whose IDs
-    /// are not found are silently ignored (e.g., if the session was reset
-    /// between the snapshot and the apply).
-    ///
-    /// Returns a [`PostProcessUpdate`] describing what changed, suitable for
-    /// sending to the frontend as a distinct event (separate from new-word
-    /// events so the UI can animate updates differently).
-    pub fn apply_postprocess(&mut self, words: Vec<TranscriptWord>) -> PostProcessUpdate {
-        let mut updated = Vec::new();
-        let mut replaced_ids = Vec::new();
-
-        for word in words {
-            if let Some(existing) = self.final_words.iter_mut().find(|w| w.id == word.id) {
-                replaced_ids.push(existing.id.clone());
-                *existing = word.clone();
-                updated.push(word);
-            }
-        }
-
-        if !updated.is_empty() {
-            self.postprocess_applied += 1;
-        }
-
-        PostProcessUpdate {
-            updated,
-            replaced_ids,
-        }
-    }
-}
-
-impl Default for TranscriptView {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-// ── Convenience conversions ──────────────────────────────────────────────────
-
-impl TranscriptFrame {
-    /// Collect all words (final + partial) in chronological order, tagged by finality.
-    /// Useful for renderers that want a single flat word list.
-    pub fn all_words(&self) -> impl Iterator<Item = (&str, bool)> {
-        self.final_words
-            .iter()
-            .map(|w| (w.text.as_str(), true))
-            .chain(self.partial_words.iter().map(|w| (w.text.as_str(), false)))
-    }
-}
-
-impl From<TranscriptView> for TranscriptFrame {
-    fn from(mut view: TranscriptView) -> Self {
-        view.flush();
-        view.frame()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use owhisper_interface::stream::{Alternatives, Channel, Metadata, ModelInfo};
-
-    fn make_response(
-        words: &[(&str, f64, f64)],
-        transcript: &str,
-        is_final: bool,
-    ) -> owhisper_interface::stream::StreamResponse {
-        owhisper_interface::stream::StreamResponse::TranscriptResponse {
-            start: 0.0,
-            duration: 0.0,
-            is_final,
-            speech_final: is_final,
-            from_finalize: false,
-            channel: Channel {
-                alternatives: vec![Alternatives {
-                    transcript: transcript.to_string(),
-                    words: words
-                        .iter()
-                        .map(|&(t, s, e)| owhisper_interface::stream::Word {
-                            word: t.to_string(),
-                            start: s,
-                            end: e,
-                            confidence: 1.0,
-                            speaker: None,
-                            punctuated_word: Some(t.to_string()),
-                            language: None,
-                        })
-                        .collect(),
-                    confidence: 1.0,
-                    languages: vec![],
-                }],
-            },
-            metadata: Metadata {
-                request_id: String::new(),
-                model_info: ModelInfo {
-                    name: String::new(),
-                    version: String::new(),
-                    arch: String::new(),
-                },
-                model_uuid: String::new(),
-                extra: None,
-            },
-            channel_index: vec![0],
-        }
-    }
-
-    fn process_sr(
-        view: &mut TranscriptView,
-        sr: &owhisper_interface::stream::StreamResponse,
-    ) -> ProcessOutcome {
-        if let Some(input) = TranscriptInput::from_stream_response(sr) {
-            view.process(input)
-        } else {
-            ProcessOutcome::Unchanged
-        }
-    }
-
-    #[test]
-    fn frame_reflects_partials() {
-        let mut view = TranscriptView::new();
-
-        process_sr(
-            &mut view,
-            &make_response(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-                false,
-            ),
-        );
-
-        let frame = view.frame();
-        assert!(frame.final_words.is_empty());
-        assert_eq!(frame.partial_words.len(), 2);
-    }
-
-    #[test]
-    fn frame_accumulates_finals_across_calls() {
-        let mut view = TranscriptView::new();
-
-        process_sr(
-            &mut view,
-            &make_response(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-                true,
-            ),
-        );
-        process_sr(
-            &mut view,
-            &make_response(&[(" foo", 1.0, 1.3), (" bar", 1.4, 1.7)], " foo bar", true),
-        );
-
-        // accumulator holds last word of each batch; flush drains them
-        view.flush();
-        let flushed = view.frame();
-        assert_eq!(flushed.final_words.len(), 4);
-        assert!(flushed.partial_words.is_empty());
-    }
-
-    #[test]
-    fn into_frame_flushes_automatically() {
-        let mut view = TranscriptView::new();
-        process_sr(
-            &mut view,
-            &make_response(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-                true,
-            ),
-        );
-        let frame: TranscriptFrame = view.into();
-        assert_eq!(frame.final_words.len(), 2);
-    }
-
-    #[test]
-    fn apply_postprocess_patches_existing_words() {
-        use crate::id::SequentialIdGen;
-        let mut view = TranscriptView::with_config(SequentialIdGen::new());
-
-        process_sr(
-            &mut view,
-            &make_response(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-                true,
-            ),
-        );
-        view.flush();
-
-        let frame = view.frame();
-        assert_eq!(frame.final_words.len(), 2);
-
-        let original_id = frame.final_words[0].id.clone();
-        let corrected_word = TranscriptWord {
-            id: original_id.clone(),
-            text: " Hello!".to_string(),
-            start_ms: frame.final_words[0].start_ms,
-            end_ms: frame.final_words[0].end_ms,
-            channel: frame.final_words[0].channel,
-        };
-
-        let update = view.apply_postprocess(vec![corrected_word]);
-        assert_eq!(update.updated.len(), 1);
-        assert_eq!(update.replaced_ids, [original_id]);
-        assert_eq!(view.frame().final_words[0].text, " Hello!");
-    }
-
-    #[test]
-    fn apply_postprocess_ignores_unknown_ids() {
-        let mut view = TranscriptView::new();
-        let update = view.apply_postprocess(vec![TranscriptWord {
-            id: "nonexistent".to_string(),
-            text: " x".to_string(),
-            start_ms: 0,
-            end_ms: 100,
-            channel: 0,
-        }]);
-        assert!(update.updated.is_empty());
-        assert!(update.replaced_ids.is_empty());
-    }
-
-    fn make_cloud_corrected_response(
-        words: &[(&str, f64, f64)],
-        transcript: &str,
-    ) -> owhisper_interface::stream::StreamResponse {
-        let mut extra = std::collections::HashMap::new();
-        extra.insert("cloud_corrected".to_string(), serde_json::Value::Bool(true));
-        extra.insert(
-            "cloud_job_id".to_string(),
-            serde_json::Value::Number(42.into()),
-        );
-
-        owhisper_interface::stream::StreamResponse::TranscriptResponse {
-            start: 0.0,
-            duration: 0.0,
-            is_final: true,
-            speech_final: true,
-            from_finalize: false,
-            channel: Channel {
-                alternatives: vec![Alternatives {
-                    transcript: transcript.to_string(),
-                    words: words
-                        .iter()
-                        .map(|&(t, s, e)| owhisper_interface::stream::Word {
-                            word: t.to_string(),
-                            start: s,
-                            end: e,
-                            confidence: 1.0,
-                            speaker: None,
-                            punctuated_word: Some(t.to_string()),
-                            language: None,
-                        })
-                        .collect(),
-                    confidence: 1.0,
-                    languages: vec![],
-                }],
-            },
-            metadata: Metadata {
-                request_id: String::new(),
-                model_info: ModelInfo {
-                    name: String::new(),
-                    version: String::new(),
-                    arch: String::new(),
-                },
-                model_uuid: String::new(),
-                extra: Some(extra),
-            },
-            channel_index: vec![0],
-        }
-    }
-
-    #[test]
-    fn cloud_corrected_response_produces_correction_variant() {
-        let sr = make_cloud_corrected_response(
-            &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-            " Hello world",
-        );
-        let input = TranscriptInput::from_stream_response(&sr).unwrap();
-        assert!(matches!(input, TranscriptInput::Correction { .. }));
-    }
-
-    #[test]
-    fn correction_replaces_matching_finalized_words() {
-        use crate::id::SequentialIdGen;
-        let mut view = TranscriptView::with_config(SequentialIdGen::new());
-
-        process_sr(
-            &mut view,
-            &make_response(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-                true,
-            ),
-        );
-        view.flush();
-        assert_eq!(view.frame().final_words.len(), 2);
-
-        let correction = TranscriptInput::Correction {
-            words: vec![
-                crate::types::RawWord {
-                    text: " Hola".to_string(),
-                    start_ms: 100,
-                    end_ms: 500,
-                    channel: 0,
-                    speaker: None,
-                },
-                crate::types::RawWord {
-                    text: " mundo".to_string(),
-                    start_ms: 600,
-                    end_ms: 900,
-                    channel: 0,
-                    speaker: None,
-                },
-            ],
-        };
-
-        let outcome = view.process(correction);
-        assert!(matches!(outcome, ProcessOutcome::Corrected(_)));
-        let frame = view.frame();
-        assert_eq!(frame.final_words.len(), 2);
-        assert_eq!(frame.final_words[0].text, " Hola");
-        assert_eq!(frame.final_words[1].text, " mundo");
-    }
-
-    #[test]
-    fn correction_with_no_matching_range_is_unchanged() {
-        let mut view = TranscriptView::new();
-
-        process_sr(
-            &mut view,
-            &make_response(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-                true,
-            ),
-        );
-        view.flush();
-
-        let correction = TranscriptInput::Correction {
-            words: vec![crate::types::RawWord {
-                text: " nope".to_string(),
-                start_ms: 5000,
-                end_ms: 6000,
-                channel: 0,
-                speaker: None,
-            }],
-        };
-
-        let outcome = view.process(correction);
-        assert!(matches!(outcome, ProcessOutcome::Unchanged));
-    }
-
-    #[test]
-    fn correction_word_count_mismatch_handled() {
-        use crate::id::SequentialIdGen;
-        let mut view = TranscriptView::with_config(SequentialIdGen::new());
-
-        process_sr(
-            &mut view,
-            &make_response(
-                &[(" Hello", 0.1, 0.5), (" world", 0.6, 0.9)],
-                " Hello world",
-                true,
-            ),
-        );
-        view.flush();
-        assert_eq!(view.frame().final_words.len(), 2);
-
-        let correction = TranscriptInput::Correction {
-            words: vec![
-                crate::types::RawWord {
-                    text: " Hola".to_string(),
-                    start_ms: 100,
-                    end_ms: 400,
-                    channel: 0,
-                    speaker: None,
-                },
-                crate::types::RawWord {
-                    text: " querido".to_string(),
-                    start_ms: 400,
-                    end_ms: 700,
-                    channel: 0,
-                    speaker: None,
-                },
-                crate::types::RawWord {
-                    text: " mundo".to_string(),
-                    start_ms: 700,
-                    end_ms: 900,
-                    channel: 0,
-                    speaker: None,
-                },
-            ],
-        };
-
-        let outcome = view.process(correction);
-        assert!(matches!(outcome, ProcessOutcome::Corrected(_)));
-        let frame = view.frame();
-        assert_eq!(frame.final_words.len(), 3);
-        assert_eq!(frame.final_words[0].text, " Hola");
-        assert_eq!(frame.final_words[1].text, " querido");
-        assert_eq!(frame.final_words[2].text, " mundo");
-    }
-}
diff --git a/crates/transcript/src/words.rs b/crates/transcript/src/words.rs
new file mode 100644
index 0000000000..9b8ec14cd5
--- /dev/null
+++ b/crates/transcript/src/words.rs
@@ -0,0 +1,246 @@
+use owhisper_interface::{batch, stream::Word};
+use uuid::Uuid;
+
+use super::types::{FinalizedWord, PartialWord, RawWord, SpeakerHint, WordState};
+
+// ── Assembly ──────────────────────────────────────────────────────────────────
+
+/// Assemble raw ASR tokens into merged `RawWord`s.
+///
+/// The transcript string is the sole oracle for word boundaries within a
+/// single response. Adjacent tokens without a space prefix are merged — no
+/// timing heuristics.
+pub(super) fn assemble(raw: &[Word], transcript: &str, channel: i32) -> Vec<RawWord> {
+    let spaced = spacing_from_transcript(raw, transcript);
+    let mut result: Vec<RawWord> = Vec::new();
+
+    for (w, text) in raw.iter().zip(&spaced) {
+        let start_ms = (w.start * 1000.0).round() as i64;
+        let end_ms = (w.end * 1000.0).round() as i64;
+
+        let should_merge = !text.starts_with(' ') && result.last().is_some();
+
+        if should_merge {
+            let last = result.last_mut().unwrap();
+            last.text.push_str(text);
+            last.end_ms = end_ms;
+            if last.speaker.is_none() {
+                last.speaker = w.speaker;
+            }
+        } else {
+            result.push(RawWord {
+                text: text.clone(),
+                start_ms,
+                end_ms,
+                channel,
+                speaker: w.speaker,
+            });
+        }
+    }
+
+    result
+}
+
+/// Assemble batch `Word`s using the same oracle-based spacing as `assemble`.
+///
+/// Unlike the streaming path, batch words don't need stitching — the response
+/// is already final. Channel index comes from the caller (position in the
+/// `results.channels` array).
+pub(super) fn assemble_batch(raw: &[batch::Word], transcript: &str, channel: i32) -> Vec<RawWord> {
+    let spaced = spacing_from_slice(
+        raw.iter()
+            .map(|w| (w.word.as_str(), w.punctuated_word.as_deref())),
+        transcript,
+    );
+    let mut result: Vec<RawWord> = Vec::new();
+
+    for (w, text) in raw.iter().zip(&spaced) {
+        let start_ms = (w.start * 1000.0).round() as i64;
+        let end_ms = (w.end * 1000.0).round() as i64;
+
+        let should_merge = !text.starts_with(' ') && result.last().is_some();
+
+        if should_merge {
+            let last = result.last_mut().unwrap();
+            last.text.push_str(text);
+            last.end_ms = end_ms;
+        } else {
+            result.push(RawWord {
+                text: text.clone(),
+                start_ms,
+                end_ms,
+                channel,
+                speaker: w.speaker.map(|s| s as i32),
+            });
+        }
+    }
+
+    result
+}
+
+/// Align each token to the transcript string and recover its spacing.
+///
+/// The transcript is the oracle: if a token is found, the whitespace before it
+/// is prepended verbatim. If not found, a space is forced ("unknown = word
+/// boundary").
+fn spacing_from_transcript(raw: &[Word], transcript: &str) -> Vec<String> {
+    spacing_from_slice(
+        raw.iter()
+            .map(|w| (w.word.as_str(), w.punctuated_word.as_deref())),
+        transcript,
+    )
+}
+
+/// Core spacing oracle: aligns each token to the transcript string and
+/// recovers the whitespace that precedes it. Works for any word source that
+/// provides `(word, punctuated_word)` pairs.
+fn spacing_from_slice<'a>(
+    tokens: impl Iterator<Item = (&'a str, Option<&'a str>)>,
+    transcript: &str,
+) -> Vec<String> {
+    let mut result = Vec::new();
+    let mut pos = 0;
+
+    for (word, punctuated) in tokens {
+        let text = punctuated.unwrap_or(word);
+        let trimmed = text.trim();
+
+        if trimmed.is_empty() {
+            result.push(text.to_string());
+            continue;
+        }
+
+        match transcript[pos..].find(trimmed) {
+            Some(found) => {
+                let abs = pos + found;
+                result.push(format!("{}{trimmed}", &transcript[pos..abs]));
+                pos = abs + trimmed.len();
+            }
+            None => {
+                let mut fallback = text.to_string();
+                if !fallback.starts_with(' ') {
+                    fallback.insert(0, ' ');
+                }
+                result.push(fallback);
+            }
+        }
+    }
+
+    result
+}
+
+// ── Pipeline stages ───────────────────────────────────────────────────────────
+
+/// Drop words already covered by the watermark (deduplication).
+pub(super) fn dedup(words: Vec<RawWord>, watermark: i64) -> Vec<RawWord> {
+    words
+        .into_iter()
+        .skip_while(|w| w.end_ms <= watermark)
+        .collect()
+}
+
+/// Cross-response word boundary handling.
+///
+/// Holds back the last word of each finalized batch so it can be merged with
+/// the first word of the next batch if the provider split a word across
+/// responses (common with Korean particles, contractions, etc.).
+///
+/// # Invariant
+///
+/// The returned held word **must** eventually be released by calling
+/// `ChannelState::drain()` at session end. Dropping a `ChannelState` that
+/// still has a held word will silently lose that word.
+pub(super) fn stitch(
+    held: Option<RawWord>,
+    mut words: Vec<RawWord>,
+) -> (Vec<RawWord>, Option<RawWord>) {
+    if words.is_empty() {
+        return (held.into_iter().collect(), None);
+    }
+
+    if let Some(h) = held {
+        if should_stitch(&h, &words[0]) {
+            words[0] = merge_words(h, words[0].clone());
+        } else {
+            words.insert(0, h);
+        }
+    }
+
+    let new_held = words.pop();
+    (words, new_held)
+}
+
+/// Maximum gap between consecutive responses for cross-response stitching.
+///
+/// 300 ms is conservative enough for most languages (including Korean particles
+/// and English contractions) without accidentally joining words from separate
+/// utterances. Providers vary in how quickly they finalize segments, so keep
+/// this tight enough to avoid false positives.
+const STITCH_MAX_GAP_MS: i64 = 300;
+
+fn should_stitch(tail: &RawWord, head: &RawWord) -> bool {
+    !head.text.starts_with(' ') && (head.start_ms - tail.end_ms) <= STITCH_MAX_GAP_MS
+}
+
+fn merge_words(mut left: RawWord, right: RawWord) -> RawWord {
+    left.text.push_str(&right.text);
+    left.end_ms = right.end_ms;
+    if left.speaker.is_none() {
+        left.speaker = right.speaker;
+    }
+    left
+}
+
+// ── Word-level transforms ─────────────────────────────────────────────────────
+
+fn ensure_space_prefix(w: &mut RawWord) {
+    if !w.text.starts_with(' ') {
+        w.text.insert(0, ' ');
+    }
+}
+
+pub(super) fn to_partial(w: &RawWord) -> PartialWord {
+    let mut text = w.text.clone();
+    if !text.starts_with(' ') {
+        text.insert(0, ' ');
+    }
+    PartialWord {
+        text,
+        start_ms: w.start_ms,
+        end_ms: w.end_ms,
+        channel: w.channel,
+    }
+}
+
+/// Convert finalized `RawWord`s into `FinalizedWord`s and `SpeakerHint`s.
+pub(super) fn finalize_words(
+    mut words: Vec<RawWord>,
+    state: WordState,
+) -> (Vec<FinalizedWord>, Vec<SpeakerHint>) {
+    words.iter_mut().for_each(ensure_space_prefix);
+
+    let mut final_words = Vec::with_capacity(words.len());
+    let mut hints = Vec::new();
+
+    for w in words {
+        let id = Uuid::new_v4().to_string();
+
+        if let Some(speaker_index) = w.speaker {
+            hints.push(SpeakerHint {
+                word_id: id.clone(),
+                speaker_index,
+            });
+        }
+
+        final_words.push(FinalizedWord {
+            id,
+            text: w.text,
+            start_ms: w.start_ms,
+            end_ms: w.end_ms,
+            channel: w.channel,
+            state,
+        });
+    }
+
+    (final_words, hints)
+}
diff --git a/plugins/listener/Cargo.toml b/plugins/listener/Cargo.toml
index 171bc927ab..57ab253489 100644
--- a/plugins/listener/Cargo.toml
+++ b/plugins/listener/Cargo.toml
@@ -32,6 +32,8 @@ hypr-mac = { workspace = true }
 hypr-vad-ext = { workspace = true }
 tauri-plugin-fs-sync = { workspace = true }
 
+hypr-transcript = { workspace = true }
+
 owhisper-client = { workspace = true }
 owhisper-interface = { workspace = true }
 
diff --git a/plugins/listener2/Cargo.toml b/plugins/listener2/Cargo.toml
index fc336f6c25..a4ab66fa67 100644
--- a/plugins/listener2/Cargo.toml
+++ b/plugins/listener2/Cargo.toml
@@ -19,6 +19,7 @@ tauri-plugin-settings = { workspace = true }
 hypr-audio-utils = { workspace = true }
 hypr-host = { workspace = true }
 hypr-language = { workspace = true }
+hypr-transcript = { workspace = true }
 
 owhisper-client = { workspace = true, features = ["argmax"] }
 owhisper-interface = { workspace = true }

From 70fee5b1ce50009e0f66d71007e0ce4d93f44199 Mon Sep 17 00:00:00 2001
From: Yujong Lee <yujonglee.dev@gmail.com>
Date: Mon, 23 Feb 2026 10:33:08 +0900
Subject: [PATCH 2/2] refactor: listener transcript and batch processing

- Remove listener utils, inline into transcript utils
- Simplify batch and general listener stores
- Update listener/listener2 plugins (events, batch, ext)
- Refactor transcript UI components and hooks

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .../note-input/transcript/shared/index.tsx    |  36 --
 .../transcript/shared/render-transcript.tsx   |  17 +-
 apps/desktop/src/hooks/useRunBatch.ts         |  75 +----
 apps/desktop/src/hooks/useStartListening.ts   |  75 +----
 apps/desktop/src/store/transcript/types.ts    |   5 +-
 apps/desktop/src/store/transcript/utils.ts    |  70 ++++
 .../src/store/zustand/listener/batch.ts       | 124 ++-----
 .../store/zustand/listener/general.test.ts    |  77 +----
 .../src/store/zustand/listener/general.ts     |  37 +--
 .../store/zustand/listener/transcript.test.ts | 314 +++++-------------
 .../src/store/zustand/listener/transcript.ts  | 221 ++----------
 .../src/store/zustand/listener/utils.test.ts  |  38 ---
 .../src/store/zustand/listener/utils.ts       |  77 -----
 .../transcript/src/pass-normalize-words.ts    |   1 +
 packages/transcript/src/shared.ts             |   7 +-
 packages/transcript/src/ui/word-span.tsx      |   6 +-
 plugins/listener/js/bindings.gen.ts           |  45 ++-
 plugins/listener/src/actors/listener/mod.rs   |  32 +-
 plugins/listener/src/events.rs                |   8 +-
 plugins/listener2/js/bindings.gen.ts          |  50 ++-
 plugins/listener2/src/batch.rs                |  43 ++-
 plugins/listener2/src/events.rs               |  10 +-
 plugins/listener2/src/ext.rs                  |   9 +-
 23 files changed, 388 insertions(+), 989 deletions(-)
 delete mode 100644 apps/desktop/src/store/zustand/listener/utils.test.ts
 delete mode 100644 apps/desktop/src/store/zustand/listener/utils.ts

diff --git a/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/index.tsx b/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/index.tsx
index c4edda3503..2472900c26 100644
--- a/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/index.tsx
+++ b/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/index.tsx
@@ -2,7 +2,6 @@ import { type RefObject, useCallback, useMemo, useRef, useState } from "react";
 import { useHotkeys } from "react-hotkeys-hook";
 
 import type { DegradedError } from "@hypr/plugin-listener";
-import type { RuntimeSpeakerHint } from "@hypr/transcript";
 import { DancingSticks } from "@hypr/ui/components/ui/dancing-sticks";
 import { cn } from "@hypr/utils";
 
@@ -46,42 +45,12 @@ export function TranscriptContainer({
   const partialWordsByChannel = useListener(
     (state) => state.partialWordsByChannel,
   );
-  const partialHintsByChannel = useListener(
-    (state) => state.partialHintsByChannel,
-  );
 
   const partialWords = useMemo(
     () => Object.values(partialWordsByChannel).flat(),
     [partialWordsByChannel],
   );
 
-  const partialHints = useMemo(() => {
-    const channelIndices = Object.keys(partialWordsByChannel)
-      .map(Number)
-      .sort((a, b) => a - b);
-
-    const offsetByChannel = new Map<number, number>();
-    let currentOffset = 0;
-    for (const channelIndex of channelIndices) {
-      offsetByChannel.set(channelIndex, currentOffset);
-      currentOffset += partialWordsByChannel[channelIndex]?.length ?? 0;
-    }
-
-    const reindexedHints: RuntimeSpeakerHint[] = [];
-    for (const channelIndex of channelIndices) {
-      const hints = partialHintsByChannel[channelIndex] ?? [];
-      const offset = offsetByChannel.get(channelIndex) ?? 0;
-      for (const hint of hints) {
-        reindexedHints.push({
-          ...hint,
-          wordIndex: hint.wordIndex + offset,
-        });
-      }
-    }
-
-    return reindexedHints;
-  }, [partialWordsByChannel, partialHintsByChannel]);
-
   const containerRef = useRef<HTMLDivElement>(null);
   const [scrollElement, setScrollElement] = useState<HTMLDivElement | null>(
     null,
@@ -169,11 +138,6 @@ export function TranscriptContainer({
                     ? partialWords
                     : []
                 }
-                partialHints={
-                  index === transcriptIds.length - 1 && currentActive
-                    ? partialHints
-                    : []
-                }
                 operations={operations}
               />
               {index < transcriptIds.length - 1 && <TranscriptSeparator />}
diff --git a/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/render-transcript.tsx b/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/render-transcript.tsx
index a1f6c34233..a77b72d3c5 100644
--- a/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/render-transcript.tsx
+++ b/apps/desktop/src/components/main/body/sessions/note-input/transcript/shared/render-transcript.tsx
@@ -1,10 +1,6 @@
 import { memo, useEffect, useMemo } from "react";
 
-import type {
-  PartialWord,
-  RuntimeSpeakerHint,
-  Segment,
-} from "@hypr/transcript";
+import type { PartialWord, Segment } from "@hypr/transcript";
 import { cn } from "@hypr/utils";
 
 import * as main from "../../../../../../../store/tinybase/store/main";
@@ -31,7 +27,6 @@ export function RenderTranscript({
   editable,
   transcriptId,
   partialWords,
-  partialHints,
   operations,
 }: {
   scrollElement: HTMLDivElement | null;
@@ -40,7 +35,6 @@ export function RenderTranscript({
   editable: boolean;
   transcriptId: string;
   partialWords: PartialWord[];
-  partialHints: RuntimeSpeakerHint[];
   operations?: Operations;
 }) {
   const finalWords = useFinalWords(transcriptId);
@@ -54,14 +48,7 @@ export function RenderTranscript({
   ) as string | undefined;
   const numSpeakers = useSessionSpeakers(sessionId);
 
-  const allSpeakerHints = useMemo(() => {
-    const finalWordsCount = finalWords.length;
-    const adjustedPartialHints = partialHints.map((hint) => ({
-      ...hint,
-      wordIndex: finalWordsCount + hint.wordIndex,
-    }));
-    return [...finalSpeakerHints, ...adjustedPartialHints];
-  }, [finalWords.length, finalSpeakerHints, partialHints]);
+  const allSpeakerHints = useMemo(() => finalSpeakerHints, [finalSpeakerHints]);
 
   const segments = useStableSegments(
     finalWords,
diff --git a/apps/desktop/src/hooks/useRunBatch.ts b/apps/desktop/src/hooks/useRunBatch.ts
index 159b2a7bd4..ce670ea409 100644
--- a/apps/desktop/src/hooks/useRunBatch.ts
+++ b/apps/desktop/src/hooks/useRunBatch.ts
@@ -5,13 +5,7 @@ import type { BatchParams } from "@hypr/plugin-listener2";
 import { useConfigValue } from "../config/use-config";
 import { useListener } from "../contexts/listener";
 import * as main from "../store/tinybase/store/main";
-import type { SpeakerHintWithId, WordWithId } from "../store/transcript/types";
-import {
-  parseTranscriptHints,
-  parseTranscriptWords,
-  updateTranscriptHints,
-  updateTranscriptWords,
-} from "../store/transcript/utils";
+import { makePersistCallback } from "../store/transcript/utils";
 import type { HandlePersistCallback } from "../store/zustand/listener/transcript";
 import { type Tab, useTabs } from "../store/zustand/tabs";
 import { id } from "../utils";
@@ -99,71 +93,8 @@ export const useRunBatch = (sessionId: string) => {
         speaker_hints: "[]",
       });
 
-      const handlePersist: HandlePersistCallback | undefined =
-        options?.handlePersist;
-
-      const persist =
-        handlePersist ??
-        ((words, hints) => {
-          if (words.length === 0) {
-            return;
-          }
-
-          const existingWords = parseTranscriptWords(store, transcriptId);
-          const existingHints = parseTranscriptHints(store, transcriptId);
-
-          const newWords: WordWithId[] = [];
-          const newWordIds: string[] = [];
-
-          words.forEach((word) => {
-            const wordId = id();
-
-            newWords.push({
-              id: wordId,
-              text: word.text,
-              start_ms: word.start_ms,
-              end_ms: word.end_ms,
-              channel: word.channel,
-            });
-
-            newWordIds.push(wordId);
-          });
-
-          const newHints: SpeakerHintWithId[] = [];
-
-          hints.forEach((hint) => {
-            if (hint.data.type !== "provider_speaker_index") {
-              return;
-            }
-
-            const wordId = newWordIds[hint.wordIndex];
-            const word = words[hint.wordIndex];
-
-            if (!wordId || !word) {
-              return;
-            }
-
-            newHints.push({
-              id: id(),
-              word_id: wordId,
-              type: "provider_speaker_index",
-              value: JSON.stringify({
-                provider: hint.data.provider ?? conn.provider,
-                channel: hint.data.channel ?? word.channel,
-                speaker_index: hint.data.speaker_index,
-              }),
-            });
-          });
-
-          updateTranscriptWords(store, transcriptId, [
-            ...existingWords,
-            ...newWords,
-          ]);
-          updateTranscriptHints(store, transcriptId, [
-            ...existingHints,
-            ...newHints,
-          ]);
-        });
+      const persist: HandlePersistCallback =
+        options?.handlePersist ?? makePersistCallback(store, transcriptId);
 
       const params: BatchParams = {
         session_id: sessionId,
diff --git a/apps/desktop/src/hooks/useStartListening.ts b/apps/desktop/src/hooks/useStartListening.ts
index ca3c1f1d19..463a2d3e50 100644
--- a/apps/desktop/src/hooks/useStartListening.ts
+++ b/apps/desktop/src/hooks/useStartListening.ts
@@ -5,14 +5,7 @@ import { commands as analyticsCommands } from "@hypr/plugin-analytics";
 import { useConfigValue } from "../config/use-config";
 import { useListener } from "../contexts/listener";
 import * as main from "../store/tinybase/store/main";
-import type { SpeakerHintWithId, WordWithId } from "../store/transcript/types";
-import {
-  parseTranscriptHints,
-  parseTranscriptWords,
-  updateTranscriptHints,
-  updateTranscriptWords,
-} from "../store/transcript/utils";
-import type { HandlePersistCallback } from "../store/zustand/listener/transcript";
+import { makePersistCallback } from "../store/transcript/utils";
 import { id } from "../utils";
 import { getSessionEventById } from "../utils/session-event";
 import { useKeywords } from "./useKeywords";
@@ -55,70 +48,6 @@ export function useStartListening(sessionId: string) {
       stt_model: conn.model,
     });
 
-    const handlePersist: HandlePersistCallback = (words, hints) => {
-      if (words.length === 0) {
-        return;
-      }
-
-      store.transaction(() => {
-        const existingWords = parseTranscriptWords(store, transcriptId);
-        const existingHints = parseTranscriptHints(store, transcriptId);
-
-        const newWords: WordWithId[] = [];
-        const newWordIds: string[] = [];
-
-        words.forEach((word) => {
-          const wordId = id();
-
-          newWords.push({
-            id: wordId,
-            text: word.text,
-            start_ms: word.start_ms,
-            end_ms: word.end_ms,
-            channel: word.channel,
-          });
-
-          newWordIds.push(wordId);
-        });
-
-        const newHints: SpeakerHintWithId[] = [];
-
-        if (conn.provider === "deepgram") {
-          hints.forEach((hint) => {
-            if (hint.data.type !== "provider_speaker_index") {
-              return;
-            }
-
-            const wordId = newWordIds[hint.wordIndex];
-            const word = words[hint.wordIndex];
-            if (!wordId || !word) {
-              return;
-            }
-
-            newHints.push({
-              id: id(),
-              word_id: wordId,
-              type: "provider_speaker_index",
-              value: JSON.stringify({
-                provider: hint.data.provider ?? conn.provider,
-                channel: hint.data.channel ?? word.channel,
-                speaker_index: hint.data.speaker_index,
-              }),
-            });
-          });
-        }
-
-        updateTranscriptWords(store, transcriptId, [
-          ...existingWords,
-          ...newWords,
-        ]);
-        updateTranscriptHints(store, transcriptId, [
-          ...existingHints,
-          ...newHints,
-        ]);
-      });
-    };
-
     start(
       {
         session_id: sessionId,
@@ -131,7 +60,7 @@ export function useStartListening(sessionId: string) {
         keywords,
       },
       {
-        handlePersist,
+        handlePersist: makePersistCallback(store, transcriptId),
       },
     );
   }, [
diff --git a/apps/desktop/src/store/transcript/types.ts b/apps/desktop/src/store/transcript/types.ts
index 4135a7df76..0857e20736 100644
--- a/apps/desktop/src/store/transcript/types.ts
+++ b/apps/desktop/src/store/transcript/types.ts
@@ -1,4 +1,7 @@
 import type { SpeakerHintStorage, WordStorage } from "@hypr/store";
 
-export type WordWithId = WordStorage & { id: string };
+export type WordWithId = WordStorage & {
+  id: string;
+  state?: "final" | "pending";
+};
 export type SpeakerHintWithId = SpeakerHintStorage & { id: string };
diff --git a/apps/desktop/src/store/transcript/utils.ts b/apps/desktop/src/store/transcript/utils.ts
index 32e9f0e248..9c61da88c4 100644
--- a/apps/desktop/src/store/transcript/utils.ts
+++ b/apps/desktop/src/store/transcript/utils.ts
@@ -1,3 +1,7 @@
+import type { TranscriptDelta } from "@hypr/plugin-listener";
+
+import { id } from "../../utils";
+import type { HandlePersistCallback } from "../zustand/listener/transcript";
 import type { SpeakerHintWithId, WordWithId } from "./types";
 
 interface TranscriptStore {
@@ -12,6 +16,7 @@ interface TranscriptStore {
     cellId: "words" | "speaker_hints",
     value: string,
   ): void;
+  transaction<T>(fn: () => T): T;
 }
 
 export function parseTranscriptWords(
@@ -66,3 +71,68 @@ export function updateTranscriptHints(
     JSON.stringify(hints),
   );
 }
+
+export function replaceTranscriptWords(
+  store: TranscriptStore,
+  transcriptId: string,
+  replacedIds: Set<string>,
+  newWords: WordWithId[],
+): void {
+  const existing = parseTranscriptWords(store, transcriptId).filter(
+    (w) => !replacedIds.has(w.id),
+  );
+  const existingHints = parseTranscriptHints(store, transcriptId).filter(
+    (h) => h.word_id == null || !replacedIds.has(h.word_id),
+  );
+  updateTranscriptWords(store, transcriptId, [...existing, ...newWords]);
+  updateTranscriptHints(store, transcriptId, existingHints);
+}
+
+export function makePersistCallback(
+  store: TranscriptStore,
+  transcriptId: string,
+): HandlePersistCallback {
+  return (delta: TranscriptDelta) => {
+    if (delta.new_words.length === 0 && delta.replaced_ids.length === 0) {
+      return;
+    }
+
+    store.transaction(() => {
+      const newWords: WordWithId[] = delta.new_words.map((w) => ({
+        id: w.id,
+        text: w.text,
+        start_ms: w.start_ms,
+        end_ms: w.end_ms,
+        channel: w.channel,
+        state: w.state,
+      }));
+
+      const newHints: SpeakerHintWithId[] = delta.hints.map((h) => ({
+        id: id(),
+        word_id: h.word_id,
+        type: "provider_speaker_index" as const,
+        value: JSON.stringify({ speaker_index: h.speaker_index }),
+      }));
+
+      if (delta.replaced_ids.length > 0) {
+        replaceTranscriptWords(
+          store,
+          transcriptId,
+          new Set(delta.replaced_ids),
+          newWords,
+        );
+      } else {
+        const existing = parseTranscriptWords(store, transcriptId);
+        updateTranscriptWords(store, transcriptId, [...existing, ...newWords]);
+      }
+
+      if (newHints.length > 0) {
+        const existingHints = parseTranscriptHints(store, transcriptId);
+        updateTranscriptHints(store, transcriptId, [
+          ...existingHints,
+          ...newHints,
+        ]);
+      }
+    });
+  };
+}
diff --git a/apps/desktop/src/store/zustand/listener/batch.ts b/apps/desktop/src/store/zustand/listener/batch.ts
index 2f7ef0f9c5..b002478d68 100644
--- a/apps/desktop/src/store/zustand/listener/batch.ts
+++ b/apps/desktop/src/store/zustand/listener/batch.ts
@@ -1,14 +1,8 @@
 import type { StoreApi } from "zustand";
 
-import type { BatchResponse, StreamResponse } from "@hypr/plugin-listener2";
+import type { BatchEvent } from "@hypr/plugin-listener2";
 
-import {
-  ChannelProfile,
-  type RuntimeSpeakerHint,
-  type WordLike,
-} from "../../../utils/segment";
 import type { HandlePersistCallback } from "./transcript";
-import { transformWordEntries } from "./utils";
 
 export type BatchPhase = "importing" | "transcribing";
 
@@ -27,12 +21,7 @@ export type BatchState = {
 
 export type BatchActions = {
   handleBatchStarted: (sessionId: string, phase?: BatchPhase) => void;
-  handleBatchResponse: (sessionId: string, response: BatchResponse) => void;
-  handleBatchResponseStreamed: (
-    sessionId: string,
-    response: StreamResponse,
-    percentage: number,
-  ) => void;
+  handleBatchEvent: (sessionId: string, event: BatchEvent) => void;
   handleBatchFailed: (sessionId: string, error: string) => void;
   clearBatchSession: (sessionId: string) => void;
   setBatchPersist: (sessionId: string, callback: HandlePersistCallback) => void;
@@ -60,62 +49,29 @@ export const createBatchSlice = <T extends BatchState>(
     }));
   },
 
-  handleBatchResponse: (sessionId, response) => {
+  handleBatchEvent: (sessionId, event) => {
     const persist = get().batchPersist[sessionId];
 
-    const [words, hints] = transformBatch(response);
-    if (!words.length) {
-      return;
-    }
-
-    persist?.(words, hints);
+    if (event.type === "batchProgress") {
+      const { delta, percentage } = event;
+      const isComplete = percentage >= 1;
 
-    set((state) => {
-      if (!state.batch[sessionId]) {
-        return state;
+      if (delta.new_words.length > 0 || delta.replaced_ids.length > 0) {
+        persist?.(delta);
       }
 
-      const { [sessionId]: _, ...rest } = state.batch;
-      return {
+      set((state) => ({
         ...state,
-        batch: rest,
-      };
-    });
-  },
-
-  handleBatchResponseStreamed: (sessionId, response, percentage) => {
-    const persist = get().batchPersist[sessionId];
-
-    if (persist && response.type === "Results") {
-      const channelIndex = response.channel_index[0];
-      const alternative = response.channel.alternatives[0];
-
-      if (channelIndex !== undefined && alternative) {
-        const [words, hints] = transformWordEntries(
-          alternative.words,
-          alternative.transcript,
-          channelIndex,
-        );
-
-        if (words.length > 0) {
-          persist(words, hints);
-        }
-      }
-    }
-
-    const isComplete = response.type === "Results" && response.from_finalize;
-
-    set((state) => ({
-      ...state,
-      batch: {
-        ...state.batch,
-        [sessionId]: {
-          percentage,
-          isComplete: isComplete || false,
-          phase: "transcribing",
+        batch: {
+          ...state.batch,
+          [sessionId]: {
+            percentage,
+            isComplete: isComplete || false,
+            phase: "transcribing",
+          },
         },
-      },
-    }));
+      }));
+    }
   },
 
   handleBatchFailed: (sessionId, error) => {
@@ -137,12 +93,8 @@ export const createBatchSlice = <T extends BatchState>(
       if (!(sessionId in state.batch)) {
         return state;
       }
-
       const { [sessionId]: _, ...rest } = state.batch;
-      return {
-        ...state,
-        batch: rest,
-      };
+      return { ...state, batch: rest };
     });
   },
 
@@ -161,44 +113,8 @@ export const createBatchSlice = <T extends BatchState>(
       if (!(sessionId in state.batchPersist)) {
         return state;
       }
-
       const { [sessionId]: _, ...rest } = state.batchPersist;
-      return {
-        ...state,
-        batchPersist: rest,
-      };
+      return { ...state, batchPersist: rest };
     });
   },
 });
-
-function transformBatch(
-  response: BatchResponse,
-): [WordLike[], RuntimeSpeakerHint[]] {
-  const allWords: WordLike[] = [];
-  const allHints: RuntimeSpeakerHint[] = [];
-  let wordOffset = 0;
-
-  response.results.channels.forEach((channel) => {
-    const alternative = channel.alternatives[0];
-    if (!alternative || !alternative.words || !alternative.words.length) {
-      return;
-    }
-
-    const [words, hints] = transformWordEntries(
-      alternative.words,
-      alternative.transcript,
-      ChannelProfile.MixedCapture,
-    );
-
-    hints.forEach((hint) => {
-      allHints.push({
-        ...hint,
-        wordIndex: hint.wordIndex + wordOffset,
-      });
-    });
-    allWords.push(...words);
-    wordOffset += words.length;
-  });
-
-  return [allWords, allHints];
-}
diff --git a/apps/desktop/src/store/zustand/listener/general.test.ts b/apps/desktop/src/store/zustand/listener/general.test.ts
index 6ed7331a69..94dfdef2a4 100644
--- a/apps/desktop/src/store/zustand/listener/general.test.ts
+++ b/apps/desktop/src/store/zustand/listener/general.test.ts
@@ -37,76 +37,29 @@ describe("General Listener Slice", () => {
 
     test("getSessionMode returns running_batch when session is in batch", () => {
       const sessionId = "session-456";
-      const { handleBatchResponseStreamed, getSessionMode } = store.getState();
+      const { handleBatchEvent, getSessionMode } = store.getState();
 
-      const mockResponse = {
-        type: "Results" as const,
-        start: 0,
-        duration: 5,
-        is_final: false,
-        speech_final: false,
-        from_finalize: false,
-        channel: {
-          alternatives: [
-            {
-              transcript: "test",
-              words: [],
-              confidence: 0.9,
-            },
-          ],
-        },
-        metadata: {
-          request_id: "test-request",
-          model_info: {
-            name: "test-model",
-            version: "1.0",
-            arch: "test-arch",
-          },
-          model_uuid: "test-uuid",
-        },
-        channel_index: [0],
-      };
-
-      handleBatchResponseStreamed(sessionId, mockResponse, 0.5);
+      handleBatchEvent(sessionId, {
+        type: "batchProgress",
+        session_id: sessionId,
+        delta: { new_words: [], hints: [], replaced_ids: [], partials: [] },
+        percentage: 0.5,
+      });
       expect(getSessionMode(sessionId)).toBe("running_batch");
     });
   });
 
   describe("Batch State", () => {
-    test("handleBatchResponseStreamed tracks progress per session", () => {
+    test("handleBatchEvent tracks progress per session", () => {
       const sessionId = "session-progress";
-      const { handleBatchResponseStreamed, clearBatchSession } =
-        store.getState();
+      const { handleBatchEvent, clearBatchSession } = store.getState();
 
-      const mockResponse = {
-        type: "Results" as const,
-        start: 0,
-        duration: 5,
-        is_final: false,
-        speech_final: false,
-        from_finalize: false,
-        channel: {
-          alternatives: [
-            {
-              transcript: "test",
-              words: [],
-              confidence: 0.9,
-            },
-          ],
-        },
-        metadata: {
-          request_id: "test-request",
-          model_info: {
-            name: "test-model",
-            version: "1.0",
-            arch: "test-arch",
-          },
-          model_uuid: "test-uuid",
-        },
-        channel_index: [0],
-      };
-
-      handleBatchResponseStreamed(sessionId, mockResponse, 0.5);
+      handleBatchEvent(sessionId, {
+        type: "batchProgress",
+        session_id: sessionId,
+        delta: { new_words: [], hints: [], replaced_ids: [], partials: [] },
+        percentage: 0.5,
+      });
       expect(store.getState().batch[sessionId]).toEqual({
         percentage: 0.5,
         isComplete: false,
diff --git a/apps/desktop/src/store/zustand/listener/general.ts b/apps/desktop/src/store/zustand/listener/general.ts
index 0936839c9d..4430702cb6 100644
--- a/apps/desktop/src/store/zustand/listener/general.ts
+++ b/apps/desktop/src/store/zustand/listener/general.ts
@@ -15,7 +15,6 @@ import {
   type SessionLifecycleEvent,
   type SessionParams,
   type SessionProgressEvent,
-  type StreamResponse,
 } from "@hypr/plugin-listener";
 import {
   type BatchParams,
@@ -311,9 +310,8 @@ export const createGeneralSlice = <
             };
           }),
         );
-      } else if (payload.type === "stream_response") {
-        const response = payload.response;
-        get().handleTranscriptResponse(response as unknown as StreamResponse);
+      } else if (payload.type === "transcript_delta") {
+        get().handleTranscriptDelta(payload.delta);
       } else if (payload.type === "mic_muted") {
         set((state) =>
           mutate(state, (draft) => {
@@ -526,21 +524,6 @@ export const createGeneralSlice = <
             return;
           }
 
-          if (payload.type === "batchProgress") {
-            get().handleBatchResponseStreamed(
-              sessionId,
-              payload.response,
-              payload.percentage,
-            );
-
-            const batchState = get().batch[sessionId];
-            if (batchState?.isComplete) {
-              cleanup();
-              resolve();
-            }
-            return;
-          }
-
           if (payload.type === "batchFailed") {
             get().handleBatchFailed(sessionId, payload.error);
             cleanup(false);
@@ -548,16 +531,16 @@ export const createGeneralSlice = <
             return;
           }
 
-          if (payload.type !== "batchResponse") {
-            return;
-          }
-
           try {
-            get().handleBatchResponse(sessionId, payload.response);
-            cleanup();
-            resolve();
+            get().handleBatchEvent(sessionId, payload);
+
+            const batchState = get().batch[sessionId];
+            if (batchState?.isComplete) {
+              cleanup();
+              resolve();
+            }
           } catch (error) {
-            console.error("[runBatch] error handling batch response", error);
+            console.error("[runBatch] error handling batch event", error);
             const errorMessage =
               error instanceof Error ? error.message : String(error);
             get().handleBatchFailed(sessionId, errorMessage);
diff --git a/apps/desktop/src/store/zustand/listener/transcript.test.ts b/apps/desktop/src/store/zustand/listener/transcript.test.ts
index 3f2ae661b6..882bd85158 100644
--- a/apps/desktop/src/store/zustand/listener/transcript.test.ts
+++ b/apps/desktop/src/store/zustand/listener/transcript.test.ts
@@ -1,9 +1,8 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, test, vi } from "vitest";
 import { createStore } from "zustand";
 
-import type { StreamResponse, StreamWord } from "@hypr/plugin-listener";
+import type { TranscriptDelta } from "@hypr/plugin-listener";
 
-import type { RuntimeSpeakerHint, WordLike } from "../../../utils/segment";
 import {
   createTranscriptSlice,
   type TranscriptActions,
@@ -16,64 +15,15 @@ const createTranscriptStore = () => {
   );
 };
 
-describe("transcript slice", () => {
-  const defaultWords: StreamWord[] = [
-    {
-      word: "another",
-      punctuated_word: "Another",
-      start: 0,
-      end: 1,
-      confidence: 1,
-      speaker: 0,
-      language: "en",
-    },
-    {
-      word: "problem",
-      punctuated_word: "problem",
-      start: 1,
-      end: 2,
-      confidence: 1,
-      speaker: 1,
-      language: "en",
-    },
-  ];
-
-  const createResponse = ({
-    words,
-    transcript,
-    isFinal,
-    channelIndex = 0,
-  }: {
-    words: StreamWord[];
-    transcript: string;
-    isFinal: boolean;
-    channelIndex?: number;
-  }): StreamResponse => {
-    return {
-      type: "Results",
-      start: 0,
-      duration: 0,
-      is_final: isFinal,
-      speech_final: isFinal,
-      from_finalize: false,
-      channel_index: [channelIndex],
-      channel: {
-        alternatives: [
-          {
-            transcript,
-            confidence: 1,
-            words,
-          },
-        ],
-      },
-      metadata: {
-        request_id: "test",
-        model_info: { name: "model", version: "1", arch: "cpu" },
-        model_uuid: "model",
-      },
-    } satisfies StreamResponse;
-  };
+const makeDelta = (partial: Partial<TranscriptDelta>): TranscriptDelta => ({
+  new_words: [],
+  hints: [],
+  replaced_ids: [],
+  partials: [],
+  ...partial,
+});
 
+describe("transcript slice", () => {
   type TranscriptStore = ReturnType<typeof createTranscriptStore>;
   let store: TranscriptStore;
 
@@ -81,197 +31,101 @@ describe("transcript slice", () => {
     store = createTranscriptStore();
   });
 
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  test("stores partial words and hints from streaming updates", () => {
-    const initialPartial = createResponse({
-      words: defaultWords,
-      transcript: "Another problem",
-      isFinal: false,
-    });
-
-    store.getState().handleTranscriptResponse(initialPartial);
-
-    const stateAfterFirst = store.getState();
-    const firstChannelWords = stateAfterFirst.partialWordsByChannel[0];
-    expect(firstChannelWords).toHaveLength(2);
-    expect(firstChannelWords?.map((word) => word.text)).toEqual([
-      " Another",
-      " problem",
-    ]);
-    expect(stateAfterFirst.partialHintsByChannel[0]).toHaveLength(2);
-    expect(stateAfterFirst.partialHintsByChannel[0]?.[0]?.wordIndex).toBe(0);
-    expect(stateAfterFirst.partialHintsByChannel[0]?.[1]?.wordIndex).toBe(1);
+  test("stores partials grouped by channel", () => {
+    store.getState().handleTranscriptDelta(
+      makeDelta({
+        partials: [
+          { text: " Hello", start_ms: 0, end_ms: 500, channel: 0 },
+          { text: " world", start_ms: 500, end_ms: 1000, channel: 0 },
+          { text: " hi", start_ms: 0, end_ms: 300, channel: 1 },
+        ],
+      }),
+    );
 
-    const extendedPartial = createResponse({
-      words: [
-        ...defaultWords,
-        {
-          word: "exists",
-          punctuated_word: "exists",
-          start: 2,
-          end: 3,
-          confidence: 1,
-          speaker: 1,
-          language: "en",
-        },
-      ],
-      transcript: "Another problem exists",
-      isFinal: false,
-    });
+    const state = store.getState();
+    expect(state.partialWordsByChannel[0]).toHaveLength(2);
+    expect(state.partialWordsByChannel[1]).toHaveLength(1);
+  });
 
-    store.getState().handleTranscriptResponse(extendedPartial);
+  test("replaces partials snapshot on each delta", () => {
+    store.getState().handleTranscriptDelta(
+      makeDelta({
+        partials: [{ text: " Hello", start_ms: 0, end_ms: 500, channel: 0 }],
+      }),
+    );
+    store.getState().handleTranscriptDelta(
+      makeDelta({
+        partials: [
+          { text: " Hello", start_ms: 0, end_ms: 500, channel: 0 },
+          { text: " world", start_ms: 500, end_ms: 1000, channel: 0 },
+        ],
+      }),
+    );
 
-    const stateAfterSecond = store.getState();
-    const updatedWords = stateAfterSecond.partialWordsByChannel[0];
-    expect(updatedWords).toHaveLength(3);
-    expect(updatedWords?.map((word) => word.text)).toEqual([
-      " Another",
-      " problem",
-      " exists",
-    ]);
-    const channelHints = stateAfterSecond.partialHintsByChannel[0] ?? [];
-    expect(channelHints).toHaveLength(3);
-    const lastPartialHint = channelHints[channelHints.length - 1];
-    expect(lastPartialHint?.wordIndex).toBe(2);
+    expect(store.getState().partialWordsByChannel[0]).toHaveLength(2);
   });
 
-  test("persists only new final words", () => {
+  test("calls persist when new_words are present", () => {
     const persist = vi.fn();
     store.getState().setTranscriptPersist(persist);
 
-    const finalResponse = createResponse({
-      words: [
-        {
-          word: "hello",
-          punctuated_word: "Hello",
-          start: 0,
-          end: 0.5,
-          confidence: 1,
-          speaker: 0,
-          language: "en",
-        },
-        {
-          word: "world",
-          punctuated_word: "world",
-          start: 0.5,
-          end: 1.5,
-          confidence: 1,
-          speaker: null,
-          language: "en",
-        },
-      ],
-      transcript: "Hello world",
-      isFinal: true,
-    });
-
-    store.getState().handleTranscriptResponse(finalResponse);
-    expect(persist).toHaveBeenCalledTimes(1);
-
-    const [words, hints] = persist.mock.calls[0] as [
-      WordLike[],
-      RuntimeSpeakerHint[],
-    ];
-    expect(words.map((word) => word.text)).toEqual([" Hello", " world"]);
-    expect(words.map((word) => word.end_ms)).toEqual([500, 1500]);
-    expect(hints).toEqual([
-      {
-        data: { type: "provider_speaker_index", speaker_index: 0 },
-        wordIndex: 0,
-      },
-    ]);
+    store.getState().handleTranscriptDelta(
+      makeDelta({
+        new_words: [
+          {
+            id: "1",
+            text: " Hello",
+            start_ms: 0,
+            end_ms: 500,
+            channel: 0,
+            state: "final",
+          },
+        ],
+      }),
+    );
 
-    store.getState().handleTranscriptResponse(finalResponse);
     expect(persist).toHaveBeenCalledTimes(1);
-    expect(store.getState().finalWordsMaxEndMsByChannel[0]).toBe(1500);
+    const delta = persist.mock.calls[0][0] as TranscriptDelta;
+    expect(delta.new_words).toHaveLength(1);
+    expect(delta.new_words[0]?.text).toBe(" Hello");
   });
 
-  test("adjusts partial hint indices after filtering partial words", () => {
+  test("calls persist when replaced_ids are present", () => {
     const persist = vi.fn();
     store.getState().setTranscriptPersist(persist);
 
-    const partialResponse = createResponse({
-      words: [
-        {
-          word: "hello",
-          punctuated_word: "Hello",
-          start: 0,
-          end: 0.5,
-          confidence: 1,
-          speaker: 0,
-          language: "en",
-        },
-        {
-          word: "world",
-          punctuated_word: "world",
-          start: 0.5,
-          end: 1.0,
-          confidence: 1,
-          speaker: 1,
-          language: "en",
-        },
-        {
-          word: "test",
-          punctuated_word: "test",
-          start: 1.1,
-          end: 1.5,
-          confidence: 1,
-          speaker: 0,
-          language: "en",
-        },
-      ],
-      transcript: "Hello world test",
-      isFinal: false,
-    });
+    store
+      .getState()
+      .handleTranscriptDelta(makeDelta({ replaced_ids: ["old-id-1"] }));
 
-    store.getState().handleTranscriptResponse(partialResponse);
-
-    const stateAfterPartial = store.getState();
-    expect(stateAfterPartial.partialWordsByChannel[0]).toHaveLength(3);
-    expect(stateAfterPartial.partialHintsByChannel[0]).toHaveLength(3);
+    expect(persist).toHaveBeenCalledTimes(1);
+  });
 
-    const finalResponse = createResponse({
-      words: [
-        {
-          word: "hello",
-          punctuated_word: "Hello",
-          start: 0,
-          end: 0.5,
-          confidence: 1,
-          speaker: 0,
-          language: "en",
-        },
-        {
-          word: "world",
-          punctuated_word: "world",
-          start: 0.5,
-          end: 1.0,
-          confidence: 1,
-          speaker: 1,
-          language: "en",
-        },
-      ],
-      transcript: "Hello world",
-      isFinal: true,
-    });
+  test("does not call persist for partial-only deltas", () => {
+    const persist = vi.fn();
+    store.getState().setTranscriptPersist(persist);
 
-    store.getState().handleTranscriptResponse(finalResponse);
+    store.getState().handleTranscriptDelta(
+      makeDelta({
+        partials: [{ text: " Hello", start_ms: 0, end_ms: 500, channel: 0 }],
+      }),
+    );
 
-    const stateAfterFinal = store.getState();
-    const remainingPartialWords = stateAfterFinal.partialWordsByChannel[0];
-    const remainingHints = stateAfterFinal.partialHintsByChannel[0] ?? [];
+    expect(persist).not.toHaveBeenCalled();
+  });
 
-    expect(remainingPartialWords).toHaveLength(1);
-    expect(remainingPartialWords?.[0]?.text).toBe(" test");
+  test("clears state on resetTranscript", () => {
+    store.getState().setTranscriptPersist(vi.fn());
+    store.getState().handleTranscriptDelta(
+      makeDelta({
+        partials: [{ text: " Hello", start_ms: 0, end_ms: 500, channel: 0 }],
+      }),
+    );
 
-    expect(remainingHints).toHaveLength(1);
-    expect(remainingHints[0]?.wordIndex).toBe(0);
+    store.getState().resetTranscript();
 
-    const hintedWord =
-      remainingPartialWords?.[remainingHints[0]?.wordIndex ?? -1];
-    expect(hintedWord).toBeDefined();
-    expect(hintedWord?.text).toBe(" test");
+    const state = store.getState();
+    expect(state.partialWordsByChannel).toEqual({});
+    expect(state.handlePersist).toBeUndefined();
   });
 });
diff --git a/apps/desktop/src/store/zustand/listener/transcript.ts b/apps/desktop/src/store/zustand/listener/transcript.ts
index 6c7858dd56..7ab35e2147 100644
--- a/apps/desktop/src/store/zustand/listener/transcript.ts
+++ b/apps/desktop/src/store/zustand/listener/transcript.ts
@@ -1,35 +1,25 @@
 import { create as mutate } from "mutative";
 import type { StoreApi } from "zustand";
 
-import type { StreamResponse } from "@hypr/plugin-listener";
+import type { PartialWord, TranscriptDelta } from "@hypr/plugin-listener";
 
-import type { RuntimeSpeakerHint, WordLike } from "../../../utils/segment";
-import { transformWordEntries } from "./utils";
+type PartialWordsByChannel = Record<number, PartialWord[]>;
 
-type WordsByChannel = Record<number, WordLike[]>;
-
-export type HandlePersistCallback = (
-  words: WordLike[],
-  hints: RuntimeSpeakerHint[],
-) => void;
+export type HandlePersistCallback = (delta: TranscriptDelta) => void;
 
 export type TranscriptState = {
-  finalWordsMaxEndMsByChannel: Record<number, number>;
-  partialWordsByChannel: WordsByChannel;
-  partialHintsByChannel: Record<number, RuntimeSpeakerHint[]>;
+  partialWordsByChannel: PartialWordsByChannel;
   handlePersist?: HandlePersistCallback;
 };
 
 export type TranscriptActions = {
   setTranscriptPersist: (callback?: HandlePersistCallback) => void;
-  handleTranscriptResponse: (response: StreamResponse) => void;
+  handleTranscriptDelta: (delta: TranscriptDelta) => void;
   resetTranscript: () => void;
 };
 
 const initialState: TranscriptState = {
-  finalWordsMaxEndMsByChannel: {},
   partialWordsByChannel: {},
-  partialHintsByChannel: {},
   handlePersist: undefined,
 };
 
@@ -38,192 +28,39 @@ export const createTranscriptSlice = <
 >(
   set: StoreApi<T>["setState"],
   get: StoreApi<T>["getState"],
-): TranscriptState & TranscriptActions => {
-  const handleFinalWords = (
-    channelIndex: number,
-    words: WordLike[],
-    hints: RuntimeSpeakerHint[],
-  ): void => {
-    const {
-      partialWordsByChannel,
-      partialHintsByChannel,
-      handlePersist,
-      finalWordsMaxEndMsByChannel,
-    } = get();
-
-    const lastPersistedEndMs = finalWordsMaxEndMsByChannel[channelIndex] ?? 0;
-    const lastEndMs = getLastEndMs(words);
-
-    const firstNewWordIndex = words.findIndex(
-      (word) => word.end_ms > lastPersistedEndMs,
-    );
-    if (firstNewWordIndex === -1) {
-      return;
-    }
-
-    const newWords = words.slice(firstNewWordIndex);
-    const newHints = hints
-      .filter((hint) => hint.wordIndex >= firstNewWordIndex)
-      .map((hint) => ({
-        ...hint,
-        wordIndex: hint.wordIndex - firstNewWordIndex,
-      }));
-
-    const existingPartialWords = partialWordsByChannel[channelIndex] ?? [];
-    const remainingPartialWords = existingPartialWords.filter(
-      (word) => word.start_ms > lastEndMs,
+): TranscriptState & TranscriptActions => ({
+  ...initialState,
+  setTranscriptPersist: (callback) => {
+    set((state) =>
+      mutate(state, (draft) => {
+        draft.handlePersist = callback;
+      }),
     );
-
-    const oldToNewIndex = new Map<number, number>();
-    let newIdx = 0;
-    for (let oldIdx = 0; oldIdx < existingPartialWords.length; oldIdx++) {
-      if (existingPartialWords[oldIdx].start_ms > lastEndMs) {
-        oldToNewIndex.set(oldIdx, newIdx);
-        newIdx++;
-      }
+  },
+  handleTranscriptDelta: (delta) => {
+    const partialWordsByChannel: PartialWordsByChannel = {};
+    for (const word of delta.partials) {
+      const ch = word.channel;
+      partialWordsByChannel[ch] ??= [];
+      partialWordsByChannel[ch].push(word);
     }
 
-    const existingPartialHints = partialHintsByChannel[channelIndex] ?? [];
-    const remainingPartialHints = existingPartialHints
-      .filter((hint) => oldToNewIndex.has(hint.wordIndex))
-      .map((hint) => ({
-        ...hint,
-        wordIndex: oldToNewIndex.get(hint.wordIndex)!,
-      }));
-
     set((state) =>
       mutate(state, (draft) => {
-        draft.partialWordsByChannel[channelIndex] = remainingPartialWords;
-        draft.partialHintsByChannel[channelIndex] = remainingPartialHints;
-        draft.finalWordsMaxEndMsByChannel[channelIndex] = lastEndMs;
+        draft.partialWordsByChannel = partialWordsByChannel;
       }),
     );
 
-    handlePersist?.(newWords, newHints);
-  };
-
-  const handlePartialWords = (
-    channelIndex: number,
-    words: WordLike[],
-    hints: RuntimeSpeakerHint[],
-  ): void => {
-    const { partialWordsByChannel, partialHintsByChannel } = get();
-    const existing = partialWordsByChannel[channelIndex] ?? [];
-
-    const firstStartMs = getFirstStartMs(words);
-    const lastEndMs = getLastEndMs(words);
-
-    const [before, after] = [
-      existing.filter((word) => word.end_ms <= firstStartMs),
-      existing.filter((word) => word.start_ms >= lastEndMs),
-    ];
-
-    const newWords = [...before, ...words, ...after];
-
-    const hintsWithAdjustedIndices = hints.map((hint) => ({
-      ...hint,
-      wordIndex: before.length + hint.wordIndex,
-    }));
-
-    const existingHints = partialHintsByChannel[channelIndex] ?? [];
-    const filteredOldHints = existingHints.filter((hint) => {
-      const word = existing[hint.wordIndex];
-      return (
-        word && (word.end_ms <= firstStartMs || word.start_ms >= lastEndMs)
-      );
-    });
-
+    if (delta.new_words.length > 0 || delta.replaced_ids.length > 0) {
+      get().handlePersist?.(delta);
+    }
+  },
+  resetTranscript: () => {
     set((state) =>
       mutate(state, (draft) => {
-        draft.partialWordsByChannel[channelIndex] = newWords;
-        draft.partialHintsByChannel[channelIndex] = [
-          ...filteredOldHints,
-          ...hintsWithAdjustedIndices,
-        ];
+        draft.partialWordsByChannel = {};
+        draft.handlePersist = undefined;
       }),
     );
-  };
-
-  return {
-    ...initialState,
-    setTranscriptPersist: (callback) => {
-      set((state) =>
-        mutate(state, (draft) => {
-          draft.handlePersist = callback;
-        }),
-      );
-    },
-    handleTranscriptResponse: (response) => {
-      if (response.type !== "Results") {
-        return;
-      }
-
-      const channelIndex = response.channel_index[0];
-      const alternative = response.channel.alternatives[0];
-      if (channelIndex === undefined || !alternative) {
-        return;
-      }
-
-      const [words, hints] = transformWordEntries(
-        alternative.words,
-        alternative.transcript,
-        channelIndex,
-      );
-      if (!words.length) {
-        return;
-      }
-
-      if (response.is_final) {
-        handleFinalWords(channelIndex, words, hints);
-      } else {
-        handlePartialWords(channelIndex, words, hints);
-      }
-    },
-    resetTranscript: () => {
-      const { partialWordsByChannel, partialHintsByChannel, handlePersist } =
-        get();
-
-      const remainingWords = Object.values(partialWordsByChannel).flat();
-
-      const channelIndices = Object.keys(partialWordsByChannel)
-        .map(Number)
-        .sort((a, b) => a - b);
-
-      const offsetByChannel = new Map<number, number>();
-      let currentOffset = 0;
-      for (const channelIndex of channelIndices) {
-        offsetByChannel.set(channelIndex, currentOffset);
-        currentOffset += partialWordsByChannel[channelIndex]?.length ?? 0;
-      }
-
-      const remainingHints: RuntimeSpeakerHint[] = [];
-      for (const channelIndex of channelIndices) {
-        const hints = partialHintsByChannel[channelIndex] ?? [];
-        const offset = offsetByChannel.get(channelIndex) ?? 0;
-        for (const hint of hints) {
-          remainingHints.push({
-            ...hint,
-            wordIndex: hint.wordIndex + offset,
-          });
-        }
-      }
-
-      if (remainingWords.length > 0) {
-        handlePersist?.(remainingWords, remainingHints);
-      }
-
-      set((state) =>
-        mutate(state, (draft) => {
-          draft.partialWordsByChannel = {};
-          draft.partialHintsByChannel = {};
-          draft.finalWordsMaxEndMsByChannel = {};
-          draft.handlePersist = undefined;
-        }),
-      );
-    },
-  };
-};
-
-const getLastEndMs = (words: WordLike[]): number =>
-  words[words.length - 1]?.end_ms ?? 0;
-const getFirstStartMs = (words: WordLike[]): number => words[0]?.start_ms ?? 0;
+  },
+});
diff --git a/apps/desktop/src/store/zustand/listener/utils.test.ts b/apps/desktop/src/store/zustand/listener/utils.test.ts
deleted file mode 100644
index 216d8352b2..0000000000
--- a/apps/desktop/src/store/zustand/listener/utils.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { describe, expect, test } from "vitest";
-
-import { fixSpacingForWords } from "./utils";
-
-describe("fixSpacingForWords", () => {
-  const testCases = [
-    {
-      transcript: "Hello",
-      input: ["Hello"],
-      output: [" Hello"],
-    },
-    {
-      transcript: "Yes. Because we",
-      input: ["Yes.", "Because", "we"],
-      output: [" Yes.", " Because", " we"],
-    },
-    {
-      transcript: "shouldn't",
-      input: ["shouldn", "'t"],
-      output: [" shouldn", "'t"],
-    },
-    {
-      transcript: "Yes. Because we shouldn't be false.",
-      input: ["Yes.", "Because", "we", "shouldn", "'t", "be", "false."],
-      output: [" Yes.", " Because", " we", " shouldn", "'t", " be", " false."],
-    },
-  ];
-
-  test.each(testCases)(
-    "transcript: $transcript",
-    ({ transcript, input, output }) => {
-      expect(output.join("")).toEqual(` ${transcript}`);
-
-      const actual = fixSpacingForWords(input, transcript);
-      expect(actual).toEqual(output);
-    },
-  );
-});
diff --git a/apps/desktop/src/store/zustand/listener/utils.ts b/apps/desktop/src/store/zustand/listener/utils.ts
deleted file mode 100644
index 67c62a20eb..0000000000
--- a/apps/desktop/src/store/zustand/listener/utils.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import type { RuntimeSpeakerHint, WordLike } from "../../../utils/segment";
-
-export function fixSpacingForWords(
-  words: string[],
-  transcript: string,
-): string[] {
-  const result: string[] = [];
-  let pos = 0;
-
-  for (const [i, word] of words.entries()) {
-    const trimmed = word.trim();
-
-    if (!trimmed) {
-      result.push(word);
-      continue;
-    }
-
-    const foundAt = transcript.indexOf(trimmed, pos);
-    if (foundAt === -1) {
-      result.push(word);
-      continue;
-    }
-
-    const prefix = i === 0 ? " " : transcript.slice(pos, foundAt);
-    result.push(prefix + trimmed);
-    pos = foundAt + trimmed.length;
-  }
-
-  return result;
-}
-
-export type WordEntry = {
-  word: string;
-  punctuated_word?: string | null;
-  start: number;
-  end: number;
-  speaker?: number | null;
-};
-
-export function transformWordEntries(
-  wordEntries: WordEntry[] | null | undefined,
-  transcript: string,
-  channel: number,
-): [WordLike[], RuntimeSpeakerHint[]] {
-  const words: WordLike[] = [];
-  const hints: RuntimeSpeakerHint[] = [];
-
-  const entries = wordEntries ?? [];
-  const textsWithSpacing = fixSpacingForWords(
-    entries.map((w) => w.punctuated_word ?? w.word),
-    transcript,
-  );
-
-  for (let i = 0; i < entries.length; i++) {
-    const word = entries[i];
-    const text = textsWithSpacing[i];
-
-    words.push({
-      text,
-      start_ms: Math.round(word.start * 1000),
-      end_ms: Math.round(word.end * 1000),
-      channel,
-    });
-
-    if (typeof word.speaker === "number") {
-      hints.push({
-        wordIndex: i,
-        data: {
-          type: "provider_speaker_index",
-          speaker_index: word.speaker,
-        },
-      });
-    }
-  }
-
-  return [words, hints];
-}
diff --git a/packages/transcript/src/pass-normalize-words.ts b/packages/transcript/src/pass-normalize-words.ts
index 8a5b799ab0..523c0ac2a2 100644
--- a/packages/transcript/src/pass-normalize-words.ts
+++ b/packages/transcript/src/pass-normalize-words.ts
@@ -34,6 +34,7 @@ const toSegmentWord = (word: WordLike, isFinal: boolean): SegmentWord => {
     end_ms: word.end_ms,
     channel: word.channel,
     isFinal,
+    isPending: isFinal && word.state === "pending",
   };
 
   if ("id" in word && word.id) {
diff --git a/packages/transcript/src/shared.ts b/packages/transcript/src/shared.ts
index 6fb0dfc36a..2ba45ecb29 100644
--- a/packages/transcript/src/shared.ts
+++ b/packages/transcript/src/shared.ts
@@ -9,11 +9,16 @@ export type WordLike = {
   start_ms: number;
   end_ms: number;
   channel: ChannelProfile;
+  state?: string;
 };
 
 export type PartialWord = WordLike;
 
-export type SegmentWord = WordLike & { isFinal: boolean; id?: string };
+export type SegmentWord = WordLike & {
+  isFinal: boolean;
+  isPending: boolean;
+  id?: string;
+};
 
 type SpeakerHintData =
   | {
diff --git a/packages/transcript/src/ui/word-span.tsx b/packages/transcript/src/ui/word-span.tsx
index ef0c9fa4b7..f1e9486462 100644
--- a/packages/transcript/src/ui/word-span.tsx
+++ b/packages/transcript/src/ui/word-span.tsx
@@ -47,8 +47,9 @@ function ViewerWordSpan({
       cn([
         audioExists && "cursor-pointer hover:bg-neutral-200/60",
         !word.isFinal && ["opacity-60", "italic"],
+        word.isPending && ["opacity-80", "text-amber-600"],
       ]),
-    [audioExists, word.isFinal],
+    [audioExists, word.isFinal, word.isPending],
   );
 
   const handleClick = useCallback(() => {
@@ -85,8 +86,9 @@ function EditorWordSpan({
       cn([
         audioExists && "cursor-pointer hover:bg-neutral-200/60",
         !word.isFinal && ["opacity-60", "italic"],
+        word.isPending && ["opacity-80", "text-amber-600"],
       ]),
-    [audioExists, word.isFinal],
+    [audioExists, word.isFinal, word.isPending],
   );
 
   const handleClick = useCallback(() => {
diff --git a/plugins/listener/js/bindings.gen.ts b/plugins/listener/js/bindings.gen.ts
index 5dc56ebaaa..ac54988646 100644
--- a/plugins/listener/js/bindings.gen.ts
+++ b/plugins/listener/js/bindings.gen.ts
@@ -110,19 +110,48 @@ sessionProgressEvent: "plugin:listener:session-progress-event"
 /** user-defined types **/
 
 export type DegradedError = { type: "authentication_failed"; provider: string } | { type: "upstream_unavailable"; message: string } | { type: "connection_timeout" } | { type: "stream_error"; message: string }
-export type SessionDataEvent = { type: "audio_amplitude"; session_id: string; mic: number; speaker: number } | { type: "mic_muted"; session_id: string; value: boolean } | { type: "stream_response"; session_id: string; response: StreamResponse }
+export type FinalizedWord = { id: string; text: string; start_ms: number; end_ms: number; channel: number; state: WordState }
+export type PartialWord = { text: string; start_ms: number; end_ms: number; channel: number }
+export type SessionDataEvent = { type: "audio_amplitude"; session_id: string; mic: number; speaker: number } | { type: "mic_muted"; session_id: string; value: boolean } | { type: "transcript_delta"; session_id: string; delta: TranscriptDelta }
 export type SessionErrorEvent = { type: "audio_error"; session_id: string; error: string; device: string | null; is_fatal: boolean } | { type: "connection_error"; session_id: string; error: string }
 export type SessionLifecycleEvent = { type: "inactive"; session_id: string; error: string | null } | { type: "active"; session_id: string; error?: DegradedError | null } | { type: "finalizing"; session_id: string }
 export type SessionParams = { session_id: string; languages: string[]; onboarding: boolean; record_enabled: boolean; model: string; base_url: string; api_key: string; keywords: string[] }
 export type SessionProgressEvent = { type: "audio_initializing"; session_id: string } | { type: "audio_ready"; session_id: string; device: string | null } | { type: "connecting"; session_id: string } | { type: "connected"; session_id: string; adapter: string }
+export type SpeakerHint = { word_id: string; speaker_index: number }
 export type State = "active" | "inactive" | "finalizing"
-export type StreamAlternatives = { transcript: string; words: StreamWord[]; confidence: number; languages?: string[] }
-export type StreamChannel = { alternatives: StreamAlternatives[] }
-export type StreamExtra = { started_unix_millis: number }
-export type StreamMetadata = { request_id: string; model_info: StreamModelInfo; model_uuid: string; extra?: StreamExtra }
-export type StreamModelInfo = { name: string; version: string; arch: string }
-export type StreamResponse = { type: "Results"; start: number; duration: number; is_final: boolean; speech_final: boolean; from_finalize: boolean; channel: StreamChannel; metadata: StreamMetadata; channel_index: number[] } | { type: "Metadata"; request_id: string; created: string; duration: number; channels: number } | { type: "SpeechStarted"; channel: number[]; timestamp: number } | { type: "UtteranceEnd"; channel: number[]; last_word_end: number } | { type: "Error"; error_code: number | null; error_message: string; provider: string }
-export type StreamWord = { word: string; start: number; end: number; confidence: number; speaker: number | null; punctuated_word: string | null; language: string | null }
+/**
+ * Delta emitted to the frontend after processing.
+ * 
+ * The frontend should:
+ * 1. Remove words listed in `replaced_ids` from TinyBase
+ * 2. Persist `new_words` to TinyBase (honoring `state`)
+ * 3. Store `partials` in ephemeral Zustand state for rendering
+ * 
+ * This shape handles all correction flows uniformly:
+ * - Normal finalization: `new_words` with `Final`, empty `replaced_ids`
+ * - Pending correction submitted: `new_words` with `Pending`, `replaced_ids`
+ * pointing at the same words' previous `Final` versions
+ * - Correction resolved: `new_words` with `Final` (corrected text),
+ * `replaced_ids` pointing at the `Pending` versions
+ */
+export type TranscriptDelta = { new_words: FinalizedWord[]; hints: SpeakerHint[]; 
+/**
+ * IDs of words superseded by `new_words`. Empty for normal finalization.
+ */
+replaced_ids: string[]; 
+/**
+ * Current in-progress words across all channels. Global snapshot.
+ */
+partials: PartialWord[] }
+/**
+ * Whether a finalized word is stable or awaiting correction.
+ * 
+ * A word is `Pending` when it has been confirmed by the STT model but a
+ * correction source (cloud STT fallback, LLM postprocessor, etc.) is still
+ * processing it. The word has an ID and is persisted, but its text may be
+ * replaced when the correction resolves via `TranscriptDelta::replaced_ids`.
+ */
+export type WordState = "final" | "pending"
 
 /** tauri-specta globals **/
 
diff --git a/plugins/listener/src/actors/listener/mod.rs b/plugins/listener/src/actors/listener/mod.rs
index d1a3356688..e3aaf20670 100644
--- a/plugins/listener/src/actors/listener/mod.rs
+++ b/plugins/listener/src/actors/listener/mod.rs
@@ -14,6 +14,7 @@ use owhisper_interface::{ControlMessage, MixedMessage};
 
 use super::session::session_span;
 use crate::{DegradedError, SessionDataEvent, SessionErrorEvent, SessionProgressEvent};
+use hypr_transcript::TranscriptProcessor;
 
 use adapters::spawn_rx_task;
 
@@ -50,6 +51,7 @@ pub struct ListenerState {
     tx: ChannelSender,
     rx_task: tokio::task::JoinHandle<()>,
     shutdown_tx: Option<tokio::sync::oneshot::Sender<()>>,
+    transcript: TranscriptProcessor,
 }
 
 pub(super) enum ChannelSender {
@@ -120,6 +122,7 @@ impl Actor for ListenerActor {
                 tx,
                 rx_task,
                 shutdown_tx: Some(shutdown_tx),
+                transcript: TranscriptProcessor::new(),
             };
 
             Ok(state)
@@ -137,6 +140,19 @@ impl Actor for ListenerActor {
             let _ = shutdown_tx.send(());
             let _ = (&mut state.rx_task).await;
         }
+
+        let delta = state.transcript.flush();
+        if !delta.is_empty() {
+            if let Err(error) = (SessionDataEvent::TranscriptDelta {
+                session_id: state.args.session_id.clone(),
+                delta: Box::new(delta),
+            })
+            .emit(&state.args.app)
+            {
+                tracing::error!(?error, "transcript_flush_emit_failed");
+            }
+        }
+
         Ok(())
     }
 
@@ -209,13 +225,15 @@ impl Actor for ListenerActor {
                     crate::actors::ChannelMode::MicAndSpeaker => {}
                 }
 
-                if let Err(error) = (SessionDataEvent::StreamResponse {
-                    session_id: state.args.session_id.clone(),
-                    response: Box::new(response),
-                })
-                .emit(&state.args.app)
-                {
-                    tracing::error!(?error, "stream_response_emit_failed");
+                if let Some(delta) = state.transcript.process(&response) {
+                    if let Err(error) = (SessionDataEvent::TranscriptDelta {
+                        session_id: state.args.session_id.clone(),
+                        delta: Box::new(delta),
+                    })
+                    .emit(&state.args.app)
+                    {
+                        tracing::error!(?error, "transcript_delta_emit_failed");
+                    }
                 }
             }
 
diff --git a/plugins/listener/src/events.rs b/plugins/listener/src/events.rs
index a8449f75eb..c7763a6499 100644
--- a/plugins/listener/src/events.rs
+++ b/plugins/listener/src/events.rs
@@ -1,4 +1,4 @@
-use owhisper_interface::stream::StreamResponse;
+use hypr_transcript::TranscriptDelta;
 
 #[macro_export]
 macro_rules! common_event_derives {
@@ -75,10 +75,10 @@ common_event_derives! {
         },
         #[serde(rename = "mic_muted")]
         MicMuted { session_id: String, value: bool },
-        #[serde(rename = "stream_response")]
-        StreamResponse {
+        #[serde(rename = "transcript_delta")]
+        TranscriptDelta {
             session_id: String,
-            response: Box<StreamResponse>,
+            delta: Box<TranscriptDelta>,
         },
     }
 }
diff --git a/plugins/listener2/js/bindings.gen.ts b/plugins/listener2/js/bindings.gen.ts
index a7d3d873b1..64c1fa2ab3 100644
--- a/plugins/listener2/js/bindings.gen.ts
+++ b/plugins/listener2/js/bindings.gen.ts
@@ -71,25 +71,49 @@ batchEvent: "plugin:listener2:batch-event"
 
 /** user-defined types **/
 
-export type BatchAlternatives = { transcript: string; confidence: number; words?: BatchWord[] }
-export type BatchChannel = { alternatives: BatchAlternatives[] }
-export type BatchEvent = { type: "batchStarted"; session_id: string } | { type: "batchResponse"; session_id: string; response: BatchResponse } | { type: "batchProgress"; session_id: string; response: StreamResponse; percentage: number } | { type: "batchFailed"; session_id: string; error: string }
+export type BatchEvent = { type: "batchStarted"; session_id: string } | { type: "batchProgress"; session_id: string; delta: TranscriptDelta; percentage: number } | { type: "batchFailed"; session_id: string; error: string }
 export type BatchParams = { session_id: string; provider: BatchProvider; file_path: string; model?: string | null; base_url: string; api_key: string; languages?: string[]; keywords?: string[] }
 export type BatchProvider = "deepgram" | "soniox" | "assemblyai" | "am"
-export type BatchResponse = { metadata: JsonValue; results: BatchResults }
-export type BatchResults = { channels: BatchChannel[] }
-export type BatchWord = { word: string; start: number; end: number; confidence: number; speaker: number | null; punctuated_word: string | null }
+export type FinalizedWord = { id: string; text: string; start_ms: number; end_ms: number; channel: number; state: WordState }
 export type JsonValue = null | boolean | number | string | JsonValue[] | Partial<{ [key in string]: JsonValue }>
-export type StreamAlternatives = { transcript: string; words: StreamWord[]; confidence: number; languages?: string[] }
-export type StreamChannel = { alternatives: StreamAlternatives[] }
-export type StreamExtra = { started_unix_millis: number }
-export type StreamMetadata = { request_id: string; model_info: StreamModelInfo; model_uuid: string; extra?: StreamExtra }
-export type StreamModelInfo = { name: string; version: string; arch: string }
-export type StreamResponse = { type: "Results"; start: number; duration: number; is_final: boolean; speech_final: boolean; from_finalize: boolean; channel: StreamChannel; metadata: StreamMetadata; channel_index: number[] } | { type: "Metadata"; request_id: string; created: string; duration: number; channels: number } | { type: "SpeechStarted"; channel: number[]; timestamp: number } | { type: "UtteranceEnd"; channel: number[]; last_word_end: number } | { type: "Error"; error_code: number | null; error_message: string; provider: string }
-export type StreamWord = { word: string; start: number; end: number; confidence: number; speaker: number | null; punctuated_word: string | null; language: string | null }
+export type PartialWord = { text: string; start_ms: number; end_ms: number; channel: number }
+export type SpeakerHint = { word_id: string; speaker_index: number }
 export type Subtitle = { tokens: Token[] }
 export type Token = { text: string; start_time: number; end_time: number; speaker: string | null }
+/**
+ * Delta emitted to the frontend after processing.
+ * 
+ * The frontend should:
+ * 1. Remove words listed in `replaced_ids` from TinyBase
+ * 2. Persist `new_words` to TinyBase (honoring `state`)
+ * 3. Store `partials` in ephemeral Zustand state for rendering
+ * 
+ * This shape handles all correction flows uniformly:
+ * - Normal finalization: `new_words` with `Final`, empty `replaced_ids`
+ * - Pending correction submitted: `new_words` with `Pending`, `replaced_ids`
+ * pointing at the same words' previous `Final` versions
+ * - Correction resolved: `new_words` with `Final` (corrected text),
+ * `replaced_ids` pointing at the `Pending` versions
+ */
+export type TranscriptDelta = { new_words: FinalizedWord[]; hints: SpeakerHint[]; 
+/**
+ * IDs of words superseded by `new_words`. Empty for normal finalization.
+ */
+replaced_ids: string[]; 
+/**
+ * Current in-progress words across all channels. Global snapshot.
+ */
+partials: PartialWord[] }
 export type VttWord = { text: string; start_ms: number; end_ms: number; speaker: string | null }
+/**
+ * Whether a finalized word is stable or awaiting correction.
+ * 
+ * A word is `Pending` when it has been confirmed by the STT model but a
+ * correction source (cloud STT fallback, LLM postprocessor, etc.) is still
+ * processing it. The word has an ID and is persisted, but its text may be
+ * replaced when the correction resolves via `TranscriptDelta::replaced_ids`.
+ */
+export type WordState = "final" | "pending"
 
 /** tauri-specta globals **/
 
diff --git a/plugins/listener2/src/batch.rs b/plugins/listener2/src/batch.rs
index 50336696d8..653536242b 100644
--- a/plugins/listener2/src/batch.rs
+++ b/plugins/listener2/src/batch.rs
@@ -3,6 +3,7 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use futures_util::StreamExt;
+use hypr_transcript::TranscriptProcessor;
 use owhisper_client::{
     AdapterKind, ArgmaxAdapter, AssemblyAIAdapter, CactusAdapter, DashScopeAdapter,
     DeepgramAdapter, ElevenLabsAdapter, FireworksAdapter, GladiaAdapter, HyprnoteAdapter,
@@ -86,20 +87,23 @@ pub struct BatchState {
     pub session_id: String,
     rx_task: tokio::task::JoinHandle<()>,
     shutdown_tx: Option<tokio::sync::oneshot::Sender<()>>,
+    transcript: TranscriptProcessor,
 }
 
 impl BatchState {
     fn emit_streamed_response(
-        &self,
+        &mut self,
         response: StreamResponse,
         percentage: f64,
     ) -> Result<(), ActorProcessingErr> {
-        BatchEvent::BatchResponseStreamed {
-            session_id: self.session_id.clone(),
-            response,
-            percentage,
+        if let Some(delta) = self.transcript.process(&response) {
+            BatchEvent::BatchResponseStreamed {
+                session_id: self.session_id.clone(),
+                delta,
+                percentage,
+            }
+            .emit(&self.app)?;
         }
-        .emit(&self.app)?;
         Ok(())
     }
 
@@ -144,6 +148,7 @@ impl Actor for BatchActor {
             session_id: args.session_id,
             rx_task,
             shutdown_tx: Some(shutdown_tx),
+            transcript: TranscriptProcessor::new(),
         };
 
         Ok(state)
@@ -158,6 +163,20 @@ impl Actor for BatchActor {
             let _ = shutdown_tx.send(());
             let _ = (&mut state.rx_task).await;
         }
+
+        let delta = state.transcript.flush();
+        if !delta.is_empty() {
+            if let Err(error) = (BatchEvent::BatchResponseStreamed {
+                session_id: state.session_id.clone(),
+                delta,
+                percentage: 1.0,
+            })
+            .emit(&state.app)
+            {
+                tracing::error!(?error, "batch_transcript_flush_emit_failed");
+            }
+        }
+
         Ok(())
     }
 
@@ -173,15 +192,7 @@ impl Actor for BatchActor {
                 percentage,
             } => {
                 tracing::info!("batch stream response received");
-
-                let is_final = matches!(
-                    response.as_ref(),
-                    StreamResponse::TranscriptResponse { is_final, .. } if *is_final
-                );
-
-                if is_final {
-                    state.emit_streamed_response(*response, percentage)?;
-                }
+                state.emit_streamed_response(*response, percentage)?;
             }
 
             BatchMsg::StreamStartFailed(error) => {
@@ -345,7 +356,7 @@ async fn spawn_argmax_streaming_batch_task(
                                 response: Box::new(event.response),
                                 percentage: event.percentage,
                             }) {
-                                tracing::error!("failed to send stream response message: {:?}", e);
+                                tracing::error!("failed to send stream response: {:?}", e);
                             }
 
                             if is_from_finalize {
diff --git a/plugins/listener2/src/events.rs b/plugins/listener2/src/events.rs
index cee053c5f6..48027caea8 100644
--- a/plugins/listener2/src/events.rs
+++ b/plugins/listener2/src/events.rs
@@ -1,5 +1,4 @@
-use owhisper_interface::batch::Response as BatchResponse;
-use owhisper_interface::stream::StreamResponse;
+use hypr_transcript::TranscriptDelta;
 
 #[macro_export]
 macro_rules! common_event_derives {
@@ -14,15 +13,10 @@ common_event_derives! {
     pub enum BatchEvent {
         #[serde(rename = "batchStarted")]
         BatchStarted { session_id: String },
-        #[serde(rename = "batchResponse")]
-        BatchResponse {
-            session_id: String,
-            response: BatchResponse,
-        },
         #[serde(rename = "batchProgress")]
         BatchResponseStreamed {
             session_id: String,
-            response: StreamResponse,
+            delta: TranscriptDelta,
             percentage: f64,
         },
         #[serde(rename = "batchFailed")]
diff --git a/plugins/listener2/src/ext.rs b/plugins/listener2/src/ext.rs
index 4c74912d60..6062c40787 100644
--- a/plugins/listener2/src/ext.rs
+++ b/plugins/listener2/src/ext.rs
@@ -1,5 +1,6 @@
 use std::sync::{Arc, Mutex};
 
+use hypr_transcript::TranscriptProcessor;
 use owhisper_client::BatchSttAdapter;
 use tauri_specta::Event;
 use tracing::Instrument;
@@ -190,13 +191,15 @@ async fn run_batch_with_adapter<A: BatchSttAdapter>(
 
         tracing::info!("batch transcription completed");
 
-        BatchEvent::BatchResponse {
+        let delta = TranscriptProcessor::process_batch_response(&response);
+        BatchEvent::BatchResponseStreamed {
             session_id: params.session_id.clone(),
-            response,
+            delta,
+            percentage: 1.0,
         }
         .emit(&app)
         .map_err(|e| {
-            crate::Error::BatchStartFailed(format!("failed to emit BatchResponse event: {e}"))
+            crate::Error::BatchStartFailed(format!("failed to emit batch delta event: {e}"))
         })?;
 
         Ok(())