diff --git a/recorder/dictation/asr.py b/recorder/dictation/asr.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fd393a424a01a3af7082245f7285936768b1ddd
--- /dev/null
+++ b/recorder/dictation/asr.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""On-device ASR via Qwen3-ASR-1.7B (MLX). Replaces mlx-whisper.
+
+Why the swap: whisper-large-v3-turbo collapses into infinite word-loops on
+multi-hour journals — its condition_on_previous_text snowballs one hallucinated
+repeat across hours until the decoder gets stuck ("crazy crazy crazy…" ×220).
+Qwen3-ASR is a dedicated ASR head with internal energy-based chunking that
+resets context per chunk, so there's nothing to snowball. On a 4.2h journal it
+produced zero runaway loops where whisper produced eleven. Runs in the same
+~/.clover-whisper/.venv (kept that name so the app's hard-coded paths still work).
+"""
+from mlx_qwen3_asr import transcribe as _transcribe
+
+MODEL = "Qwen/Qwen3-ASR-1.7B"
+
+
+def transcribe_text(audio):
+    """Plain text (marker dictation)."""
+    return _transcribe(audio, model=MODEL).text.strip()
+
+
+def transcribe_segments(audio):
+    """Whisper-shaped [{start, end, text}] with coarse timestamps. Qwen emits
+    very fine segments (often one word); merge_segments() coarsens them so the
+    per-segment forced-aligner isn't called tens of thousands of times."""
+    r = _transcribe(audio, model=MODEL, return_timestamps=True)
+    segs = [{"start": float(s["start"]), "end": float(s["end"]), "text": s["text"].strip()}
+            for s in (getattr(r, "segments", None) or [])
+            if (s.get("text") or "").strip()]
+    return merge_segments(segs)
+
+
+def merge_segments(segs, max_gap=3.0, max_dur=30.0):
+    """Glue adjacent segments split by < max_gap of silence, up to max_dur.
+
+    Qwen emits very fine segments (often one word). Two reasons to coarsen:
+    the per-segment forced-aligner shouldn't run tens of thousands of times,
+    and render() starts a new paragraph at every gap between segments — so with
+    raw Qwen segments a gappy gaming monologue shatters into dozens of one-line
+    paragraphs. Merging across pauses up to max_gap (> render's PAUSE_SPLIT)
+    makes the surviving boundaries — and thus paragraphs — whisper-sized, while
+    max_dur still breaks a long unbroken monologue."""
+    out = []
+    for s in segs:
+        if (out and s["start"] - out[-1]["end"] <= max_gap
+                and s["end"] - out[-1]["start"] <= max_dur):
+            out[-1]["end"] = s["end"]
+            out[-1]["text"] = (out[-1]["text"] + " " + s["text"]).strip()
+        else:
+            out.append(dict(s))
+    return out
diff --git a/recorder/dictation/backfill_transcripts.py b/recorder/dictation/backfill_transcripts.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0c5391dc87a8c96cdde2dca76160ed300521df2
--- /dev/null
+++ b/recorder/dictation/backfill_transcripts.py
@@ -0,0 +1,138 @@
+#!/usr/bin/env python3
+"""Re-transcribe every archived session with Qwen3-ASR-1.7B, replacing the old
+whisper transcripts (which collapsed into word-loops on long recordings).
+
+Walks the archive for dirs holding both mic.m4a and transcript.md, longest audio
+first, and re-runs session_transcript.py in place. The old transcript.md /
+transcript.json / speakers.json are preserved once as *.whisper.<ext> before the
+first overwrite, so nothing is lost.
+
+Mode (solo vs multi) is inferred from the existing speakers.json: multi if it
+recorded more than one speaker or any non-"You" / unknown voice, else solo. The
+title is taken from the old transcript's H1, falling back to the folder name.
+
+    python backfill_transcripts.py [--roots DIR ...] [--dry-run] [--limit N]
+"""
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+SESSION_SCRIPT = os.path.join(HERE, "session_transcript.py")
+PY = sys.executable  # this venv's python (has qwen + deps)
+# Only the recorder's own output trees — walking all of Archive drags across the
+# 2018-2025 media library on the NAS. Journal + Sessions per year is where
+# mic.m4a/transcript.md live.
+import glob as _glob
+DEFAULT_ROOTS = sorted(
+    _glob.glob("/Volumes/clover/Archive/*/Journal")
+    + _glob.glob("/Volumes/clover/Archive/*/Sessions"))
+
+
+def audio_duration(path):
+    try:
+        out = subprocess.run(
+            ["ffprobe", "-v", "error", "-show_entries", "format=duration",
+             "-of", "csv=p=0", path],
+            capture_output=True, text=True, timeout=60)
+        return float(out.stdout.strip())
+    except Exception:
+        return 0.0
+
+
+def find_sessions(roots):
+    found = []
+    for root in roots:
+        for dirpath, _dirs, files in os.walk(root):
+            if "mic.m4a" in files and "transcript.md" in files:
+                found.append(dirpath)
+    return found
+
+
+# "You" is the solo label; "Clover" is Chloe's own enrolled voice name (self-
+# enroll), so it is NOT a guest. Phantom "Speaker N" (unknown=true) is exactly the
+# solo-voice fragmentation the cluster fallback produces — not a real person.
+SELF_LABELS = {"You", "Clover"}
+
+
+def infer_mode(folder):
+    """multi ONLY if a genuine, named guest was recorded. Journaling/improv is
+    solo; the old cluster fallback shattered the solo voice into phantom
+    "Speaker N", which must not resurrect a multi-speaker run (and, worse, run
+    pyannote over a multi-hour file)."""
+    try:
+        spk = json.load(open(os.path.join(folder, "speakers.json"))).get("speakers", [])
+    except Exception:
+        return "solo"
+    for s in spk:
+        lab = s.get("label")
+        if lab and lab not in SELF_LABELS and not lab.startswith("Speaker "):
+            return "multi"
+    return "solo"
+
+
+def title_of(folder):
+    md = os.path.join(folder, "transcript.md")
+    try:
+        for line in open(md):
+            if line.startswith("# "):
+                return line[2:].strip()
+    except Exception:
+        pass
+    return os.path.basename(folder)
+
+
+def backup_once(folder):
+    """Preserve the whisper-era outputs the first time we touch this folder."""
+    for name in ("transcript.md", "transcript.json", "speakers.json"):
+        src = os.path.join(folder, name)
+        base, ext = os.path.splitext(name)
+        dst = os.path.join(folder, f"{base}.whisper{ext}")
+        if os.path.exists(src) and not os.path.exists(dst):
+            shutil.copy2(src, dst)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--roots", nargs="+", default=DEFAULT_ROOTS)
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--limit", type=int, default=0)
+    args = ap.parse_args()
+
+    sessions = find_sessions(args.roots)
+    ranked = sorted(sessions, key=lambda d: audio_duration(os.path.join(d, "mic.m4a")),
+                    reverse=True)
+    if args.limit:
+        ranked = ranked[:args.limit]
+
+    print(f"{len(ranked)} sessions to backfill (longest first)\n")
+    for i, folder in enumerate(ranked, 1):
+        mic = os.path.join(folder, "mic.m4a")
+        dur = audio_duration(mic) / 60
+        mode = infer_mode(folder)
+        title = title_of(folder)
+        markers = os.path.join(folder, "markers.json")
+        markers_arg = markers if os.path.exists(markers) else "none"
+        tag = f"[{i}/{len(ranked)}] {os.path.basename(folder)}  {dur:.0f}min  {mode}"
+        if args.dry_run:
+            print(f"DRY {tag}  title={title!r}")
+            continue
+        print(f"==> {tag}")
+        backup_once(folder)
+        t = time.time()
+        r = subprocess.run(
+            [PY, SESSION_SCRIPT, mic, markers_arg,
+             os.path.join(folder, "transcript.md"), title, mode],
+            capture_output=True, text=True)
+        if r.returncode != 0:
+            print(f"    FAILED ({r.returncode}): {r.stderr.strip().splitlines()[-1:]}" )
+        else:
+            print(f"    done in {(time.time()-t)/60:.1f} min")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/recorder/dictation/forced_align.py b/recorder/dictation/forced_align.py
index 7d62d36a64700e1da0f685234d0a7f29b4e4f026..675a10a9dcd62c22e2c8e1c593a973d35a164b9b 100644
--- a/recorder/dictation/forced_align.py
+++ b/recorder/dictation/forced_align.py
@@ -34,12 +34,12 @@ def align_segment(data, sr, start, end, text):
     seg = data[a:b]
     raw = text.split()
     if len(seg) < int(0.2 * sr) or not raw:
-        return [{"word": w, "start": start, "end": end} for w in raw]
+        return [{"word": w, "start": start, "end": end, "conf": None} for w in raw]
 
     norm = [_norm(w) for w in raw]
     idx = [i for i, n in enumerate(norm) if n]
     if not idx:
-        return [{"word": w, "start": start, "end": end} for w in raw]
+        return [{"word": w, "start": start, "end": end, "conf": None} for w in raw]
 
     model, tok, aligner = _load()
     wav = torch.from_numpy(np.ascontiguousarray(seg)).unsqueeze(0)
@@ -48,23 +48,30 @@ def align_segment(data, sr, start, end, text):
     try:
         spans = aligner(emit[0], tok([norm[i] for i in idx]))
     except Exception:
-        return [{"word": w, "start": start, "end": end} for w in raw]
+        return [{"word": w, "start": start, "end": end, "conf": None} for w in raw]
 
     ratio = wav.shape[1] / emit.shape[1] / sr
-    times = {}
+    times, confs = {}, {}
     for k, i in enumerate(idx):
         s = spans[k]
         times[i] = (round(start + s[0].start * ratio, 3), round(start + s[-1].end * ratio, 3))
+        # per-word acoustic confidence = mean CTC score over its token spans
+        # (0..1). A word that doesn't match the audio scores low → flag it.
+        sc = [float(getattr(tsp, "score", 0.0)) for tsp in s]
+        confs[i] = round(sum(sc) / len(sc), 3) if sc else 0.0
 
-    out = [{"word": w, "start": None, "end": None} for w in raw]
+    out = [{"word": w, "start": None, "end": None, "conf": None} for w in raw]
     for i, t in times.items():
         out[i]["start"], out[i]["end"] = t
-    # Interpolate unaligned words from neighbours.
+        out[i]["conf"] = confs[i]
+    # Interpolate unaligned words from neighbours; conf 0.0 marks them as guessed
+    # (pure numbers/symbols the aligner can't score).
     last_end = start
     for i, o in enumerate(out):
         if o["start"] is None:
             o["start"] = last_end
             nxt = next((out[j]["start"] for j in range(i + 1, len(out)) if out[j]["start"]), end)
             o["end"] = nxt
+            o["conf"] = 0.0
         last_end = o["end"]
     return out
diff --git a/recorder/dictation/merge_sentences.py b/recorder/dictation/merge_sentences.py
new file mode 100644
index 0000000000000000000000000000000000000000..f978a611e56fc590aad8784cfd9056b851f8afe6
--- /dev/null
+++ b/recorder/dictation/merge_sentences.py
@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Merge adjacent cleaned segments that are obviously ONE sentence split by a
+gameplay pause (seg[i] doesn't end in terminal punctuation and seg[i+1] starts
+lowercase). The merged segment spans both time windows; re-alignment on the
+merged text then re-derives word timings across the pause, so nothing about the
+sequencer's per-word data breaks.
+
+    python merge_sentences.py <cleaned.json> <out.json>
+"""
+import json
+import sys
+
+TERMINAL = ".!?…\"')"
+
+
+def should_merge(a, b):
+    at = a["text"].rstrip()
+    bt = b["text"].lstrip()
+    if not at or not bt:
+        return False
+    # first segment left hanging (no sentence end) and the next continues lowercase
+    return at[-1] not in TERMINAL and bt[:1].islower()
+
+
+def main():
+    segs = json.load(open(sys.argv[1]))["segments"]
+    out = []
+    for s in segs:
+        if out and should_merge(out[-1], s):
+            out[-1]["end"] = s["end"]
+            out[-1]["text"] = (out[-1]["text"].rstrip() + " " + s["text"].lstrip()).strip()
+        else:
+            out.append(dict(s))
+    json.dump({"segments": out}, open(sys.argv[2], "w"))
+    print(f"{len(segs)} -> {len(out)} segments ({len(segs) - len(out)} merged)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/recorder/dictation/realign.py b/recorder/dictation/realign.py
new file mode 100644
index 0000000000000000000000000000000000000000..c78c001657a37e11163de489b5e7fb73b2c56881
--- /dev/null
+++ b/recorder/dictation/realign.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Re-run word-level forced alignment on cleaned segment text and write a
+sequencer-shaped transcript.json ({segments:[{start,end,text,label,words}]}).
+
+Used to graft cleaned text (punctuation + corrected proper nouns) back onto real
+per-word timings: alignment is re-derived from the CLEANED words against the
+audio, so word start/end stay accurate and the sequencer's karaoke captions keep
+working. Runs in ~/.clover-whisper/.venv (needs torchaudio).
+
+    python realign.py <audio> <cleaned_segments.json> <out_transcript.json> [labels.json]
+
+cleaned_segments.json: {segments:[{start,end,text}]} (order/count preserved).
+"""
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import speaker_id as sid
+
+
+def main():
+    audio, seg_path, out_path = sys.argv[1:4]
+    labels_path = sys.argv[4] if len(sys.argv) > 4 else None
+
+    segs = json.load(open(seg_path))["segments"]
+    labels = None
+    if labels_path and os.path.exists(labels_path):
+        labels = json.load(open(labels_path))
+
+    data, sr = sid.load_audio(audio)
+    try:
+        import forced_align as fa
+    except Exception:
+        fa = None
+
+    out = []
+    for i, s in enumerate(segs):
+        start, end, text = float(s["start"]), float(s["end"]), s["text"]
+        words = fa.align_segment(data, sr, start, end, text) if fa else []
+        seg = {"start": start, "end": end, "text": text, "words": words}
+        if labels and i < len(labels):
+            seg["label"] = labels[i]
+        elif "label" in s:
+            seg["label"] = s["label"]
+        out.append(seg)
+
+    json.dump({"segments": out}, open(out_path, "w"))
+    nwords = sum(len(s["words"]) for s in out)
+    print(f"realigned {len(out)} segments, {nwords} words -> {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/recorder/dictation/reconcile.py b/recorder/dictation/reconcile.py
new file mode 100644
index 0000000000000000000000000000000000000000..40bc1776dfe3d5f4373f3df6fef551a71e3e0e16
--- /dev/null
+++ b/recorder/dictation/reconcile.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+"""Dual-pass reconcile: keep the UNBIASED transcript as the content backbone
+(contextual biasing improves proper nouns but can drop whole phrases — e.g.
+"Tor doesn't know" vanished under a glossary), and graft in the BIASED pass's
+spellings only where a glossary name lines up with a mishear.
+
+    python reconcile.py <unbiased_segs.json> <biased_segs.json> <glossary.json> <out.json>
+
+Output preserves the unbiased segment boundaries + every unbiased word (nothing
+dropped); only substitutes a token when the biased pass replaced it with a
+known on-screen/glossary name. Word timings are re-derived downstream by realign.
+"""
+import difflib
+import json
+import re
+import sys
+
+
+def norm(w):
+    return re.sub(r"[^a-z0-9']", "", w.lower())
+
+
+def flatten(segs):
+    """[(token, seg_index)] across all segments, in order."""
+    out = []
+    for i, s in enumerate(segs):
+        for tok in s["text"].split():
+            out.append((tok, i))
+    return out
+
+
+def canonize(text, gjoined):
+    """Collapse a glossary name the ASR split across tokens back to its canonical
+    spelling: 'Delta Rune' -> 'Deltarune'. Longest window first. Applied to the
+    BIASED pass (it heard the names) before reconcile aligns the two passes."""
+    toks = text.split()
+    out, i = [], 0
+    while i < len(toks):
+        hit = None
+        for w in (3, 2):                      # only multi-token joins; singles are unchanged
+            if i + w <= len(toks):
+                j = "".join(norm(t) for t in toks[i:i + w])
+                if j in gjoined:
+                    hit = (w, gjoined[j])
+                    break
+        if hit:
+            out.extend(hit[1].split())
+            i += hit[0]
+        else:
+            out.append(toks[i])
+            i += 1
+    return " ".join(out)
+
+
+def main():
+    unb = json.load(open(sys.argv[1]))["segments"]
+    bia = json.load(open(sys.argv[2]))["segments"]
+    ctx = json.load(open(sys.argv[3]))
+    # The work title ("Deltarune") is the name most likely to be split/misheard,
+    # but it lives in `app`, not the character glossary — fold it in.
+    gloss = list(ctx.get("glossary", []))
+    if ctx.get("app"):
+        gloss.append(ctx["app"])
+    out_path = sys.argv[4]
+
+    # glossary as a set of normalized name tokens (multiword names split), plus
+    # a joined-spelling lookup so a name the ASR split across tokens ("Delta
+    # Rune" -> "deltarune") maps back to its canonical form ("Deltarune").
+    gset = set()
+    gjoined = {}
+    for name in gloss:
+        for t in re.split(r"[\s']", name):
+            if len(norm(t)) > 1:
+                gset.add(norm(t))
+        j = norm(name)
+        if len(j) > 3:
+            gjoined[j] = name
+
+    for s in bia:                         # 'Delta Rune' -> 'Deltarune' before aligning
+        s["text"] = canonize(s["text"], gjoined)
+
+    U = flatten(unb)
+    B = flatten(bia)
+    un_tok = [norm(t) for t, _ in U]
+    bi_tok = [norm(t) for t, _ in B]
+
+    # Rebuild per-segment token lists, substituting biased NAMES over unbiased
+    # mishears. Never drop an unbiased token; never add a biased-only token
+    # (that's where content loss lived). seg_flags parallels seg_tokens: True =
+    # the two ASR passes DISAGREED on this word (a 'replace' region) → genuine
+    # uncertainty about what was said, worth flagging. 'delete' regions (biasing
+    # dropped content) are NOT flagged — the unbiased word there is fine.
+    seg_tokens = [[] for _ in unb]
+    seg_flags = [[] for _ in unb]
+    sm = difflib.SequenceMatcher(a=un_tok, b=bi_tok, autojunk=False)
+    subs = 0
+
+    def add(seg, tok, flag):
+        seg_tokens[seg].append(tok)
+        seg_flags[seg].append(flag)
+
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "equal":                          # both passes agree → confident
+            for k in range(i1, i2):
+                add(U[k][1], U[k][0], False)
+        elif tag == "delete":                       # unbiased-only → KEEP (content), confident
+            for k in range(i1, i2):
+                add(U[k][1], U[k][0], False)
+        elif tag == "insert":                       # biased-only → skip
+            continue
+        elif tag == "replace":
+            seg = U[i1][1] if i1 < len(U) else len(unb) - 1
+            uconcat = "".join(norm(U[k][0]) for k in range(i1, i2))
+            bconcat = "".join(norm(B[k][0]) for k in range(j1, j2))
+            # (a) The biased pass heard a full on-screen name that the ASR split
+            # across tokens: "Delta Rune"->"deltarune" == glossary "Deltarune".
+            # Graft the canonical spelling — UNLESS what was actually said is a
+            # TRUNCATION of it (a strict prefix, "Tor" of "Toriel"): that's a
+            # deliberate trimmed utterance, keep it verbatim + flag.
+            canon = gjoined.get(bconcat) or gjoined.get(uconcat)
+            truncation = canon and bconcat.startswith(uconcat) and len(uconcat) <= 0.6 * len(bconcat)
+            if canon and not truncation:
+                for nm in canon.split():
+                    add(seg, nm, False)
+                subs += 1
+                continue
+            # (b) Single-token re-spelling (night->Knight), not a completion.
+            # Verbatim beats canonical: reject when biased is meaningfully longer
+            # (the model completing a word it didn't fully hear).
+            b_names = [B[k][0] for k in range(j1, j2) if norm(B[k][0]) in gset]
+            u_len = sum(len(norm(U[k][0])) for k in range(i1, i2))
+            b_len = sum(len(norm(B[k][0])) for k in range(j1, j2))
+            not_expansion = b_len <= u_len + (i2 - i1)   # ~1 extra char per word
+            if b_names and len(b_names) >= (j2 - j1) - 1 and not_expansion:
+                for nm in [B[k][0] for k in range(j1, j2)]:
+                    add(seg, nm, False)
+                subs += len(b_names)
+            else:
+                # passes disagreed and we kept the unbiased word → FLAG uncertain
+                for k in range(i1, i2):
+                    add(U[k][1], U[k][0], True)
+
+    out_segs = []
+    for s, toks, flags in zip(unb, seg_tokens, seg_flags):
+        out_segs.append({"start": s["start"], "end": s["end"], "text": " ".join(toks).strip(),
+                         "uncertain": flags})
+    json.dump({"segments": out_segs}, open(out_path, "w"))
+    n_unc = sum(sum(f) for f in seg_flags)
+    print(f"reconciled {len(out_segs)} segments, {subs} name-substitutions, "
+          f"{n_unc} words flagged uncertain -> {out_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/recorder/dictation/session_transcript.py b/recorder/dictation/session_transcript.py
index 40b3a11947c0da9e9d4a214e8ddacfb51c1221d2..b8dddbf1c286ff023e5aaafa242b533ce0ae7b45 100644
--- a/recorder/dictation/session_transcript.py
+++ b/recorder/dictation/session_transcript.py
@@ -15,9 +15,9 @@ import subprocess
 import sys
 
 import numpy as np
-import mlx_whisper
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import asr
 import speaker_id as sid
 from transcript_render import PAUSE_SPLIT, render
 
@@ -182,10 +182,7 @@ def main():
     mode = sys.argv[5] if len(sys.argv) > 5 else "solo"
     folder = os.path.dirname(out_path)
 
-    segments = mlx_whisper.transcribe(
-        audio, path_or_hf_repo="mlx-community/whisper-large-v3-turbo"
-    ).get("segments", [])
-    segments = [{"start": s["start"], "end": s["end"], "text": s["text"]} for s in segments]
+    segments = asr.transcribe_segments(audio)
 
     data, sr = sid.load_audio(audio)
     try:
diff --git a/recorder/dictation/transcribe.py b/recorder/dictation/transcribe.py
index 0bc6aa70de6a73ce5ea9e23774a6805b46508f6c..3fe5c751a4b18c25230c5fdd8c09d48c31e1e345 100644
--- a/recorder/dictation/transcribe.py
+++ b/recorder/dictation/transcribe.py
@@ -1,20 +1,18 @@
 #!/usr/bin/env python3
-"""Transcribe an audio file with MLX Whisper (large-v3-turbo) and print the text.
+"""Transcribe an audio file with Qwen3-ASR-1.7B (MLX) and print the text.
 
 Used by Clover Recorder's marker overlay for voice notes. Runs against the venv
 created by setup-dictation.sh (~/.clover-whisper/.venv).
 
     python transcribe.py <audio-file>
 """
+import os
 import sys
 
-import mlx_whisper
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from asr import transcribe_text
 
 if len(sys.argv) < 2:
     sys.exit("usage: transcribe.py <audio-file>")
 
-result = mlx_whisper.transcribe(
-    sys.argv[1],
-    path_or_hf_repo="mlx-community/whisper-large-v3-turbo",
-)
-print(result["text"].strip())
+print(transcribe_text(sys.argv[1]))
diff --git a/recorder/dictation/transcribe_ctx.py b/recorder/dictation/transcribe_ctx.py
new file mode 100644
index 0000000000000000000000000000000000000000..634fe565290c702c9981366d3fd9e47bb864ac82
--- /dev/null
+++ b/recorder/dictation/transcribe_ctx.py
@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""Transcribe audio with Qwen3-ASR biased by a context string (the on-screen
+glossary), writing whisper-shaped merged segments. This is where proper nouns get
+fixed at the source — the ASR recognizes "Toriel"/"Cyber World" natively when the
+names are in its context.
+
+    python transcribe_ctx.py <audio> <context.txt|none> <out_segments.json>
+"""
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+import asr
+from mlx_qwen3_asr import transcribe
+
+audio, ctx_path, out_path = sys.argv[1:4]
+context = ""
+if ctx_path and ctx_path != "none" and os.path.exists(ctx_path):
+    context = open(ctx_path).read().strip()
+
+r = transcribe(audio, model=asr.MODEL, return_timestamps=True, context=context)
+segs = [{"start": float(s["start"]), "end": float(s["end"]), "text": (s.get("text") or "").strip()}
+        for s in (getattr(r, "segments", None) or []) if (s.get("text") or "").strip()]
+segs = asr.merge_segments(segs)
+json.dump({"segments": segs}, open(out_path, "w"))
+print(f"{len(segs)} segments -> {out_path}")
diff --git a/recorder/docs/transcription-pipeline.md b/recorder/docs/transcription-pipeline.md
new file mode 100644
index 0000000000000000000000000000000000000000..964ac3f6551bb5bdbeb681dafdd1919764e143ef
--- /dev/null
+++ b/recorder/docs/transcription-pipeline.md
@@ -0,0 +1,123 @@
+# Clover Recorder — transcription pipeline
+
+How a recorded session becomes a clean, screen-aware, word-aligned transcript.
+This is the design as of the 2026-07 rework; the base ASR swap is **shipped**, the
+screen-context + annotation stack is **prototyped on the eval bench** (not yet
+wired into the app) and is what we're reviewing before a full backlog re-run.
+
+## The shape
+
+```mermaid
+flowchart TD
+    subgraph CAP["Capture (during session)"]
+        MIC["🎙️ mic.m4a<br/>your voice"]
+        SCR["🖥️ screen-1/2.mov<br/>both monitors"]
+    end
+
+    %% --- Screen context (runs first, feeds the ASR) ---
+    SCR --> VIS["<b>Vision OCR</b><br/>sample frames → Qwen3-VL<br/>read names/UI off screen"]
+    VIS --> GEXP["<b>Glossary expand</b><br/>Qwen3 LLM: identify the game,<br/>add canonical lore not on screen"]
+    GEXP --> GLOSS[("Glossary<br/>+ ASR context")]
+
+    %% --- Dual-pass ASR ---
+    MIC --> ASRU["<b>ASR — unbiased</b><br/>Qwen3-ASR-1.7B<br/><i>content backbone</i>"]
+    MIC --> ASRB["<b>ASR — biased</b><br/>Qwen3-ASR-1.7B + glossary context<br/><i>names right at the source</i>"]
+    GLOSS -. context .-> ASRB
+    ASRU --> RECON["<b>Reconcile</b><br/>unbiased words (keep all content)<br/>+ graft biased name spellings"]
+    ASRB --> RECON
+    GLOSS -. names .-> RECON
+
+    %% --- Text cleanup ---
+    RECON --> CLEAN["<b>Cleanup LLM</b><br/>Qwen3-30B-A3B<br/>punctuation · casing · residual names"]
+    GLOSS -. glossary .-> CLEAN
+    CLEAN --> MERGE["<b>Sentence-merge</b><br/>rejoin sentences split by pauses"]
+    MERGE --> ALIGN["<b>Forced re-align</b><br/>torchaudio MMS_FA<br/>per-word start/end from audio"]
+
+    %% --- Layers on top of the aligned words ---
+    ALIGN --> STAM["<b>Stammer marking</b><br/>from word gaps:<br/>I-I-I · making… making"]
+    MIC --> DEMUX["<b>Demucs</b><br/>isolate voice from game audio"]
+    DEMUX --> CLAP["<b>CLAP tags</b><br/>sigh · singing · laughter"]
+    ALIGN -. segment spans .-> CLAP
+
+    %% --- Output ---
+    STAM --> OUT[("transcript.md<br/>transcript.json")]
+    CLAP --> OUT
+    ALIGN --> OUT
+    OUT --> SEQ["🎬 Sequencer<br/>karaoke captions<br/>(uses word timings)"]
+
+    classDef shipped fill:#1f6f43,stroke:#2ea043,color:#fff;
+    classDef proto fill:#6a4bc8,stroke:#8a6fe8,color:#fff;
+    class ASRU shipped;
+    class VIS,GEXP,ASRB,RECON,CLEAN,MERGE,STAM,DEMUX,CLAP proto;
+```
+
+Green = shipped today. Purple = prototyped, pending this review.
+
+## Stage by stage
+
+1. **Vision OCR** — sample frames from both monitors, read them with a local
+   Qwen3-VL. Strict "only what's on screen" prompt (no lore hallucination). Yields
+   the proper nouns actually visible: `KRIS`, `SUSIE`, `Flowery`, item names…
+
+2. **Glossary expand** — a local Qwen3 LLM identifies the work from those names
+   (Kris/Susie ⇒ *Deltarune*) and **adds its canonical characters/places that were
+   never on screen** — `Toriel`, `Knight`, `Cyber World`, `Dark World`. OCR grounds
+   it; the LLM fills the story vocabulary. Output doubles as the ASR context string.
+
+3. **Dual-pass ASR** — the workhorse, the cheap 1.7B model, run twice:
+   - *unbiased* → the **content backbone** (verbatim, nothing dropped);
+   - *biased* (same model + glossary as `context`) → names correct **at the source**
+     (`the night` → `the Knight`, `Cy World` → `Cyber World`), and sometimes *more*
+     accurate — it correctly heard Flowery's "I found a **glue**" meme.
+   - **Reconcile** keeps every unbiased word and grafts biased name spellings only
+     where they line up. Why both: biasing improves names but can *drop* whole
+     phrases (it deleted "Tor doesn't know") — the unbiased pass guarantees content.
+
+4. **Cleanup LLM** (Qwen3-30B-A3B) — punctuation, capitalization, and any residual
+   name misses, using the glossary. Verbatim otherwise: stammers and repeats are
+   preserved, never smoothed away.
+
+5. **Sentence-merge** — rejoin a sentence that a gameplay pause split across
+   segments (`…made your dad end up` │ `like this` → one sentence).
+
+6. **Forced re-align** (torchaudio MMS_FA) — re-derive per-word start/end by
+   aligning the *cleaned* words back to the audio. This is what keeps the
+   sequencer's word-level karaoke captions correct after all the text edits.
+
+7. **Stammer marking** — purely from the word gaps: rapid repeats hyphenate
+   (`I'm-I'm-I'm`), paused restarts get dots (`making… making`). Verbatim, just
+   shows the disfluency shape.
+
+8. **Annotation layer** (optional) — **Demucs** splits your voice off the game
+   audio, then **CLAP** tags non-speech per segment (`sigh`, `singing`, `laughter`).
+   Isolating the voice first is what makes this work *during* gameplay — on the raw
+   mix, game music masks everything.
+
+Output: `transcript.md` (readable) + `transcript.json` (segments + words + labels +
+annotations) → the sequencer reads word timings from the JSON.
+
+## Model tiers (the scale-down)
+
+| Stage | Ceiling (proven) | Production pick | Notes |
+|---|---|---|---|
+| ASR | Qwen3-ASR-1.7B | **same** | 1.7B is already SOTA; ~21× realtime |
+| Vision OCR | Qwen3-VL-235B | **Qwen3-VL-32B** | OCR doesn't need the giant; verify |
+| Glossary expand | Qwen3-235B | **Qwen3-235B** or 32B | lore knowledge helps here |
+| Cleanup | Qwen3-235B | **Qwen3-30B-A3B (~18 GB)** | 4B comma-splices; 30B holds |
+
+Production tier is ~18 GB models running one at a time — nowhere near the 256 GB
+ceiling.
+
+## Open items before the backlog run
+
+- **Name-fixing consistency.** With dual-pass, names sit in misheard form in the
+  reconciled text, and the 30B cleanup fixes them *inconsistently* (`Knight` once,
+  `night` twice in one sentence). Fix candidates: morphology-aware reconcile
+  (graft `Knight` over `night`/`Knights`), a stronger cleanup pass, or a
+  fix-all-instances prompt. **This is the main thing to nail.**
+- **Vision model** — confirm 32B OCR matches the 235B before locking it in.
+- **Cost of the full run** — vision + dual ASR + cleanup + Demucs + CLAP per
+  session, across the backlog. Worth a per-hour estimate before kicking it off.
+- Annotations (stammer/CLAP) are **layers** — they can ship after the core text
+  pipeline without reworking it.
+```
diff --git a/recorder/engine/Sources/recorder/MenubarApp.swift b/recorder/engine/Sources/recorder/MenubarApp.swift
index c984b70a4d64c924de0d0934abe48139a5a8256d..3c054c5697dc3a4e890f90f915f7e992a855eabc 100644
--- a/recorder/engine/Sources/recorder/MenubarApp.swift
+++ b/recorder/engine/Sources/recorder/MenubarApp.swift
@@ -1042,7 +1042,7 @@ final class AppController: NSObject, NSApplicationDelegate, NSPopoverDelegate, N
     guard FileManager.default.isExecutableFile(atPath: python),
       let script = Bundle.main.url(forResource: "session_transcript", withExtension: "py")?.path
     else {
-      reportProblem("Transcription skipped — whisper env missing (run setup-dictation.sh).")
+      reportProblem("Transcription skipped — dictation env missing (run setup-dictation.sh).")
       return
     }
     let markers = dir.appendingPathComponent("markers.json")
diff --git a/recorder/setup-dictation.sh b/recorder/setup-dictation.sh
index 179796cdc2967ec18e71d8c4accdc9127cbac55f..5ec5e8b62ed77fd8699d8ae0e49d5b1c77f280d4 100644
--- a/recorder/setup-dictation.sh
+++ b/recorder/setup-dictation.sh
@@ -1,9 +1,11 @@
 #!/usr/bin/env bash
-# One-time: set up local Whisper for the marker overlay's voice dictation.
+# One-time: set up local ASR for the marker overlay's voice dictation and
+# session transcripts.
 #
-# Creates a venv at ~/.clover-whisper with MLX Whisper (Apple-Silicon optimized)
-# and pre-downloads large-v3-turbo (~1.5 GB). Transcription then runs fully
-# on-device in ~1.5 s per note on this machine.
+# Creates a venv at ~/.clover-whisper (name kept for the app's hard-coded paths)
+# with Qwen3-ASR-1.7B (Apple-Silicon optimized via MLX) and pre-downloads the
+# model (~3.4 GB). Transcription then runs fully on-device. Qwen replaced
+# whisper-large-v3-turbo, which collapsed into word-loops on multi-hour journals.
 #
 #   bash ~/devel/creative-toolkit/recorder/setup-dictation.sh
 set -euo pipefail
@@ -13,14 +15,15 @@ echo "==> creating venv at $DIR"
 mkdir -p "$DIR"
 cd "$DIR"
 uv venv
-# mlx-whisper: transcription · speechbrain/torchaudio/scipy: speaker ID + clustering
-uv pip install mlx-whisper speechbrain torchaudio scipy
+# mlx-qwen3-asr[aligner]: transcription (the [aligner] extra pulls nagisa, which
+# Qwen's timestamp path needs whenever a clip contains Japanese text — without it
+# transcription crashes mid-session) · speechbrain/torchaudio/scipy: speaker ID
+uv pip install "mlx-qwen3-asr[aligner]" speechbrain torchaudio scipy
 
-echo "==> pre-downloading whisper-large-v3-turbo (one-time)"
-say -o /tmp/clover-dictation-warm.aiff "Clover dictation is ready." 2>/dev/null || true
-"$DIR/.venv/bin/python" - /tmp/clover-dictation-warm.aiff <<'PY' || true
-import sys, mlx_whisper
-mlx_whisper.transcribe(sys.argv[1], path_or_hf_repo="mlx-community/whisper-large-v3-turbo")
+echo "==> pre-downloading Qwen3-ASR-1.7B (one-time, ~3.4 GB)"
+"$DIR/.venv/bin/python" - <<'PY' || true
+from huggingface_hub import snapshot_download
+snapshot_download("Qwen/Qwen3-ASR-1.7B")
 PY
 
 echo "✅ dictation ready ($DIR/.venv/bin/python)"
diff --git a/sequencer/CLAUDE.md b/sequencer/CLAUDE.md
index 3a0f69b0a1db32b6da3dbc60a735d6c368d4f1a0..32bb75e44efc85d19fee601d636cc40bd6493f5d 100644
--- a/sequencer/CLAUDE.md
+++ b/sequencer/CLAUDE.md
@@ -21,11 +21,13 @@ swift run Sequencer --selftest <mediafile>   # headless pipeline check (see Self
 swift run Sequencer --uitest                  # offscreen TimelineView harness (see UITest.swift)
 swift run Sequencer --perftest <file.sq>      # offscreen draw-timing harness (see PerfTest.swift)
 swift run Sequencer --cachetest <file.sq> [capGB]  # cache-budget invariant check (see Cachetest.swift)
+swift run Sequencer --snappinch <file.sq> [pps] [origin] [steps] [outPrefix]  # zoom-transient detector (see PerfTest.swift)
 ```
 
 - `--selftest` exercises the real media pipeline against a file you pass in: ffprobe, filmstrip/waveform generation, chunk-proxy building, AVFoundation playability of the built proxy, and prints sample Fusion Lua output. Useful when touching `MediaPipeline.swift` or `ChunkedProxy.swift`.
 - `--uitest` hosts the real `TimelineView` in an offscreen window and drives it with synthetic `NSEvent`s (move, trim, slip, stretch, box select, split, links, storyboard split, comp parsing, fades, plus file-format migration/round-trip — ~100 assertions, PASS/FAIL printer). Useful when touching timeline gesture code.
 - `--perftest` loads a real `.sq` into an offscreen `TimelineView` and times `draw(_:)` at several zoom levels, printing **median and p90** ms/frame (medians resist the I/O spikes async thumbnail loads inject) plus a per-section `DrawProf` breakdown and tile blit/render counts. Each zoom is measured **direct vs tiled, in the same process** (thermal drift between runs otherwise swamps real deltas — this machine varies 5× with battery/heat), under two pan patterns: `scroll` (8 px/frame, a real gesture) and `jump` (half-project teleports, cache-hostile). Use it when touching timeline **drawing**. Lessons baked into `TimelineView`: never build/tint an `NSImage(systemSymbolName:)` per clip per frame — bake once via `bakedSymbol(...)`; never draw geometry millions of points wide (clamp to the cull window; CG "clips" it but pays anyway); and detail is a function of **on-screen clip width** (`lodMinWidth`), never of whether the user is scrolling.
+- `--snappinch` simulates a continuous zoom gesture and draws every frame TWICE with identical state, diffing the pair — any difference is a transient rendering bug (this is the harness that caught the one-frame waveform corruption: CoreGraphics' *antialiased* rasterizer corrupts large concurrent path fills across the parallel cold-frame lane contexts, which is why `drawWaveform` fills with `setShouldAntialias(false)` — do not re-enable AA there). `--snapzoom` is its single-step cousin (settled → transient → settled PNGs).
 - `--cachetest` loads a real `.sq` (headless), jumps the playhead across the timeline, and continuously asserts the cache-budget invariant (`ledger ≤ cap`, disk ≤ cap + slack) while demand builds and evictions run — plus coverage of the chunk under the playhead at each stop. Use it when touching the budget/eviction logic in `MediaPipeline.swift` or `ChunkedProxy.swift`. Run it against a project whose full proxy set exceeds the cap (pass a small `capGB`) — that's the regime it exists to test. Don't run it while the GUI app is open (two processes would fight over one cache).
 
 Cache/proxy debugging levers: `SEQ_BUILDLOG=1` logs every chunk-build START and admission failure (`[cache] start/admission blocked` — success completions are otherwise silent, so this is how you chase "why isn't chunk X building"). The viewer logs every "Loading Media…" spinner occurrence as a `[miss]` line with a cause diagnosis from `ChunkManager.missDiagnosis` (chunk missing/building/queued-where, composition-lag, player-late, budget-starved) and, on recovery, its duration. **All `[miss]` lines and important `[cache]` events (rescues, build/stitch failures, admission blocks, orphan reaping) also append to `~/Library/Logs/Sequencer.log`** (`SeqLog`, 5 MB rotation) — no Console attach or special launch needed; a user-reported spinner sighting is answerable from that file. `sequencer --layertest <cacheKey:origPath> […]` opens bare AVPlayerLayer tiles playing the real stitched composition(s) (`SEQ_LAYERTEST_T=<sec>` sets the seek) — the isolation tool that cracked the black-viewer bug.
@@ -36,6 +38,16 @@ Bundle id: `net.paperclover.Sequencer` (defaults domain too; renamed from com.cl
 
 `ProjectModel.laneRefs` (and `hasStoryboard`) scan every clip — O(clips). Never call them per-clip in a draw or per-frame path: `laneRect→laneRefs` per drawn clip was quadratic and pegged a core at 98% on big projects. `TimelineView` uses its `laneRows` cache (invalidated in `redraw()`/`ctx.didSet`); route new hot paths through that.
 
+**All 60 Hz queries go through `store.index` (`ClipIndex.swift`), never the model's filters.** `ProjectModel.clipAt`/`clips(on:)`/etc. are O(clips) filter passes, and `Clip` is a fat value type (it inlines `Board`) — each pass COPIES every clip it touches, and at 60 Hz from player sync + viewer cells + transport + subtitles that was a constant drizzle of 100–700 ms `[hang]`s (`initializeWithCopy value witness for Sequencer.Clip`). `ClipIndex` is rebuilt lazily per model change (`Store.project.didSet` invalidates) and answers `clipAt`/`nextDifferentClip`/`boundaryClips`/`audibleClips` by binary search; uitest #43 asserts parity with the model (including the `max(by:)` first-of-equal-starts tie-break). Cold paths (event handlers, export) may still use the model directly.
+
+**Audio proxies (2026-07-22): audio has its own cache and absolute build priority.** Every sound-bearing media file gets a local audio-only extraction (`<cacheRoot>/_audio/<key>.mov`, ffmpeg stream-copy with AAC fallback, `MediaPipeline.ensureAudioProxy`) — audio playback otherwise streams NAS originals, which stutter exactly when video chunk encodes are hammering the same volume. The `_audio` subroot has a **separate budget** (`maxAudioCacheGB`, default 8): its bytes are excluded from the chunk ledger and from whole-dir eviction, so video pressure can never evict audio. Extraction is queued at doc open ahead of everything, and `ChunkManager.nextJob` holds the *fill* tier (never window/urgent) while any of the project's audio proxies are pending. `AudioAssetCache` builds its comps from the proxy when present (rebuilding in the background when one lands; players adopt it at their next item install, never mid-stream), and audio-file clips play the proxy directly (`TrackPlayer.setClip` — a live item is never swapped just because the proxy landed).
+
+**Never read `player.currentTime()` on the main thread — use `TrackPlayer.playedSeconds`** (the item's `CMTimebase`, a lock-free read). `currentTime()` dispatches to the player's internal queue under the FigPlayer mutex; a busy queue holds it for SECONDS (the worst logged mid-playback hangs, 4+ s). The timebase is the clock the render pipeline itself advances — same value, no queue hop; it returns nil (treat as "unknown, skip the check") until an item's timebase exists.
+
+**Playback audio is decoupled from proxies (2026-07-17, the "audio cuts out" fix).** Video `TrackPlayer`s are ALWAYS muted; a video clip's sound plays through its own per-clip audio player in `PlayerManager.syncAudio` (window: 1 s lookahead / 0.5 s linger — same gapless-handover trick as audio clips) reading an **audio-only composition of the ORIGINAL file** from `AudioAssetCache` (per-cacheKey, built async, failure = retry-with-backoff, never cache an empty comp). Rationale: composition audio had silent holes wherever chunks weren't built, and every `replaceCurrentItem` dropped sound. Consequently `ChunkManager.assemble` builds NO audio track, and mid-playback item swaps are **reveal-only** (`had == nil` — the playhead chunk was previously uncovered); pure quality upgrades wait for the next pause/seek/cut, because a live-player item swap drops a beat of video and stalls main on the player-queue mutex (`FigPlayerAsyncDispatch…` `[hang]`s). Lipsync: video-clip audio players use driftTolerance 0.15/resyncGap 1.0 (pure audio 0.30/2.0, video 0.08/0.5).
+
+Main-thread FS rule, extended: **any per-tick disk touch must be memoized or async** — `MediaPipeline.isOffline` (stale-while-revalidate, background stat), `proxyURL` (5 s existence memo), `ChunkManager.cachedIsNetworkPath` (statfs off-main, prewarmed in `startServices`; a cold NAS statfs blocks for SECONDS), thumbnail path building (`appendingPathComponent(_, isDirectory: false)` — the unhinted overload getattrlists). Viewer stand-ins: prefer `fineThumbImage` (0.5 s grid), and `filmstripImage(at:maxDistance:)` refuses a coarse keyframe thumb >2.5 s away — nearest-keyframe on long-GOP screen recordings could be tens of seconds off, which is the "scrubbing shows unrelated frames" bug. Related trap: **`player.currentTime()` updates the instant a seek completes, but the AVPlayerLayer keeps presenting the PREVIOUS decoded frame until the new one lands** — never reveal a player layer based on its reported time alone. The paused reveal gates on `TrackPlayer.isSettling` (seek in flight / just-completed / just-installed grace), and `recentlyInstalled` skips synchronous `currentTime()` reads entirely (they block main on the busy player queue — the `FigPlayer…` mutex `[hang]`s).
+
 Two hard-won main-thread rules (2026-07-12): (1) **`URL(fileURLWithPath:)` without `isDirectory:` stats the path** — `MediaItem.url`/`displayName` did this per clip label per timeline draw against NAS paths, freezing the UI whenever the volume was cold (292/337 draw samples in `stat()`). Always pass `isDirectory:` for known-file paths; `displayName` uses `(path as NSString).lastPathComponent` (no I/O). (2) **Nothing between `thread_suspend` and `thread_resume` may allocate or lock** — the hang sampler's `Array.append` needed the malloc lock the suspended main thread held → permanent app freeze (the "unusably laggy on startup" report). `sampleMainStack` uses preallocated buffers; keep it allocation-free. Related: the SIGTERM/SIGINT DispatchSources live on a background queue, not main — a wedged main thread must not make the app unkillable.
 
 Microhangs/stutter: `HangMonitor` (a watchdog thread pinging the main queue every 20 ms) logs every main-thread stall >100 ms as a `[hang]` line in `~/Library/Logs/Sequencer.log` — duration, whether playback was running (`during playback (rate …)`), and a **symbolicated stack of the main thread sampled mid-stall** (mach `thread_suspend` + arm64 frame-pointer walk + `swift_demangle`), so the culprit is named without Instruments. `SEQ_NOHANGWATCH=1` disables it; `SEQ_HANGTEST=1` injects a deliberate 0.4 s spin ~2 s after launch to verify the pipeline end-to-end. User-reported stutter during long sessions is answerable from that file.
diff --git a/sequencer/Sources/Sequencer/AppDelegate.swift b/sequencer/Sources/Sequencer/AppDelegate.swift
index a3c73704dd827f88ef9c1c1c1de5b9a1ec9061cf..b2304d1e5918131a70dac282586930ad379112fe 100644
--- a/sequencer/Sources/Sequencer/AppDelegate.swift
+++ b/sequencer/Sources/Sequencer/AppDelegate.swift
@@ -142,7 +142,11 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         file.addItem(.separator())
         file.addItem(item("Import Media…", #selector(SequencerWindowController.importMedia), key: "i"))
         file.addItem(.separator())
-        file.addItem(item("Export…", #selector(SequencerWindowController.showExport), key: "e"))
+        file.addItem(item("Export Media…", #selector(SequencerWindowController.showExport), key: "e"))
+        file.addItem(item("Export Selection to REAPER…", #selector(SequencerWindowController.exportReaper),
+                          key: "e", mods: [.command, .shift]))
+        file.addItem(item("Open in REAPER", #selector(SequencerWindowController.openInReaper),
+                          key: "e", mods: [.command, .option]))
         file.addItem(.separator())
         file.addItem(item("Reveal Cache in Finder", #selector(revealCache), target: self))
         file.addItem(item("Reveal Project in Finder", #selector(SequencerWindowController.revealProject)))
@@ -164,7 +168,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         clip.addItem(item("Split", #selector(SequencerWindowController.split(_:)), key: "s", mods: []))
         clip.addItem(item("Move Overlaps to Separate Tracks", #selector(SequencerWindowController.moveOverlaps),
                           key: "o", mods: [.option]))
-        clip.addItem(item("Mute", #selector(SequencerWindowController.muteClips), key: "m", mods: [.option]))
+        clip.addItem(item("Mute", #selector(SequencerWindowController.muteClips), key: "p", mods: []))
         clip.addItem(.separator())
         clip.addItem(item("Nudge Left 1 Frame", #selector(SequencerWindowController.nudgeLeft),
                           key: fkey(NSLeftArrowFunctionKey), mods: []))
@@ -189,6 +193,9 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
                           key: fkey(NSLeftArrowFunctionKey), mods: [.option]))
         clip.addItem(item("Ripple Trim End to Playhead", #selector(SequencerWindowController.rippleTrimRight),
                           key: fkey(NSRightArrowFunctionKey), mods: [.option]))
+        // ⇧A / ⇧D — same trim, but leave the freed span as a gap (no ripple).
+        clip.addItem(item("Delete Left", #selector(SequencerWindowController.deleteLeft), key: "A", mods: [.shift]))
+        clip.addItem(item("Delete Right", #selector(SequencerWindowController.deleteRight), key: "D", mods: [.shift]))
         main.addItem(submenu(clip, title: "Clip"))
 
         // Every storyboard command lives together here, whether the underlying
@@ -237,6 +244,12 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         view.addItem(item("Previews on Left", #selector(SequencerWindowController.togglePreviewsLeft),
                           key: "l", mods: [.option, .command]))
         view.addItem(item("Pop Out Previews", #selector(SequencerWindowController.togglePopout), key: "P"))
+        view.addItem(.separator())
+        // A second (third, …) view onto the same timeline: its own zoom/scroll,
+        // sharing the playhead / selection / tracks. Routes to whichever timeline
+        // window is key (base action on TimelineHostWindowController).
+        view.addItem(item("New Timeline Window", #selector(TimelineHostWindowController.newTimelineWindow),
+                          key: "t", mods: [.command, .shift]))
         main.addItem(submenu(view, title: "View"))
 
         let play = NSMenu(title: "Playback")
diff --git a/sequencer/Sources/Sequencer/ChunkedProxy.swift b/sequencer/Sources/Sequencer/ChunkedProxy.swift
index b43b429fdcfcadc2f025700f0bccde3e9a3d54a1..d70e0988335b93b664d87b03613488d8fced8743 100644
--- a/sequencer/Sources/Sequencer/ChunkedProxy.swift
+++ b/sequencer/Sources/Sequencer/ChunkedProxy.swift
@@ -189,13 +189,13 @@ final class ChunkManager {
             .appendingPathComponent("chunks", isDirectory: true)
     }
     private func chunkURL(key: String, index: Int) -> URL {
-        chunksDir(key).appendingPathComponent(String(format: "c%06d.mov", index))
+        chunksDir(key).appendingPathComponent(String(format: "c%06d.mov", index), isDirectory: false)
     }
     private func rescueURL(key: String, index: Int) -> URL {
-        chunksDir(key).appendingPathComponent(String(format: "r%06d.mov", index))
+        chunksDir(key).appendingPathComponent(String(format: "r%06d.mov", index), isDirectory: false)
     }
     private func manifestURL(_ key: String) -> URL {
-        chunksDir(key).appendingPathComponent("widths.json")
+        chunksDir(key).appendingPathComponent("widths.json", isDirectory: false)
     }
 
     /// Legacy width assumed for a chunk on disk with no manifest entry — the
@@ -237,7 +237,7 @@ final class ChunkManager {
             // adaptive controller would only learn that AFTER the user
             // stared at a placeholder. It climbs back once builds measure
             // comfortably fast; background upgrades restore full quality.
-            if media.width >= 2560, Self.isNetworkPath(media.path) {
+            if media.width >= 2560, Self.cachedIsNetworkPath(media.path) {
                 s.qualityIndex = 2
             }
             let widths = loadWidths(media.cacheKey)
@@ -769,23 +769,28 @@ final class ChunkManager {
     /// A playable (file, time-in-file) pair that shows `sourceTime` — the
     /// sharpest thing on disk right now: legacy full proxy, built chunk,
     /// covering rescue slice, or the original when it's known playable. nil
-    /// when this frame genuinely can't be decoded yet. Feeds the RAM frame
-    /// cache's stand-in decodes; main-thread.
-    func frameSource(media: MediaItem, sourceTime: Double) -> (url: URL, time: Double)? {
+    /// when this frame genuinely can't be decoded yet. `atTarget` says whether
+    /// that source is full-tier quality (target-width chunk, legacy proxy, or
+    /// the original) or a reduced stand-in (below-target chunk, rescue slice)
+    /// — the RAM frame cache records it so the strip can show tier, and so a
+    /// reduced frame gets re-decoded once a better source lands. Main-thread.
+    func frameSource(media: MediaItem, sourceTime: Double)
+        -> (url: URL, time: Double, atTarget: Bool)? {
         guard !media.isAudio else { return nil }
         if let proxy = MediaPipeline.shared.proxyURL(for: media) {
-            return (proxy, sourceTime)
+            return (proxy, sourceTime, true)
         }
         let s = state(for: media)
         let i = Self.chunkIndex(forSource: sourceTime)
         let local = sourceTime - Double(i) * Self.chunkSeconds
-        if s.built[i] != nil {
-            return (chunkURL(key: media.cacheKey, index: i), local)
+        if let w = s.built[i] {
+            return (chunkURL(key: media.cacheKey, index: i), local,
+                    w >= targetWidth(for: media))
         }
         if let p = s.partial[i], local >= p.offset, local <= p.offset + p.dur - 0.05 {
-            return (rescueURL(key: media.cacheKey, index: i), local - p.offset)
+            return (rescueURL(key: media.cacheKey, index: i), local - p.offset, false)
         }
-        if s.originalPlayable == true { return (media.url, sourceTime) }
+        if s.originalPlayable == true { return (media.url, sourceTime, true) }
         return nil
     }
 
@@ -926,7 +931,15 @@ final class ChunkManager {
         }
         // 3. Whole-project background fill for chunks off-screen of the
         //    prefetch window — the tier that stops when the cache is full.
-        guard !fillStarved else { return nil }
+        //    Audio outranks it absolutely: while this project's audio proxies
+        //    are still extracting, the fill yields the NAS reads to them
+        //    (audio is minutes of small copies; the fill is hours of encodes —
+        //    and stuttering SOUND is the artifact users forgive least).
+        //    Window/urgent jobs above still run: the frame under the playhead
+        //    can't wait. Extraction completion re-pumps via budgetChanged.
+        guard !fillStarved,
+              !MediaPipeline.shared.audioProxiesPending(for: ctx.store.project)
+        else { return nil }
         for (key, s) in states {
             guard let media = mediaByKey[key] else { continue }
             for i in s.background where s.built[i] == nil
@@ -1191,13 +1204,38 @@ final class ChunkManager {
 
     /// Whether a path lives on a network mount (SMB/NFS NAS) rather than a
     /// local disk — a fast, data-free `statfs`. Used to decide whether a slow
-    /// build can honestly be blamed on network I/O.
+    /// build can honestly be blamed on network I/O. "Fast" only when the mount
+    /// is warm — statfs of a COLD/unreachable NAS blocks for seconds, so this
+    /// must never run on the main thread (build workers call it directly).
     static func isNetworkPath(_ path: String) -> Bool {
         var st = statfs()
         guard statfs(path, &st) == 0 else { return false }
         return (st.f_flags & UInt32(MNT_LOCAL)) == 0
     }
 
+    // Main-thread-safe view of `isNetworkPath`: answers from cache, resolving
+    // misses on a background queue (assume local until known otherwise — the
+    // adaptive quality ladder recovers from a wrong first guess; a wedged main
+    // thread doesn't).
+    private nonisolated(unsafe) static var netPathCache: [String: Bool] = [:]   // main-thread only
+    private nonisolated(unsafe) static var netPathPending = Set<String>()       // main-thread only
+    private static let netPathQueue = DispatchQueue(label: "sequencer.netpath",
+                                                    qos: .userInitiated)
+    static func cachedIsNetworkPath(_ path: String) -> Bool {
+        if let v = netPathCache[path] { return v }
+        if !netPathPending.contains(path) {
+            netPathPending.insert(path)
+            netPathQueue.async {
+                let v = isNetworkPath(path)
+                DispatchQueue.main.async {
+                    netPathPending.remove(path)
+                    netPathCache[path] = v
+                }
+            }
+        }
+        return false
+    }
+
     // MARK: - Adaptive quality
 
     /// Any media currently held back by a network read the box can't keep up
@@ -1352,12 +1390,17 @@ final class ChunkManager {
         guard let vTrack = comp.addMutableTrack(
             withMediaType: .video, preferredTrackID: kCMPersistentTrackID_Invalid)
         else { return (comp, false) }
-        let aTrack = media.hasAudio ? comp.addMutableTrack(
-            withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid) : nil
+        // NO audio track: playback sound comes from per-clip original-audio
+        // players (PlayerManager.syncAudio / AudioAssetCache), never from this
+        // composition — its audio would be full of uncovered-chunk holes, and
+        // the video players render it muted anyway. Export builds its own
+        // composition from originals. Skipping audio here also halves the
+        // track loads on every reassembly (one per landed chunk).
+        let aTrack: AVMutableCompositionTrack? = nil
 
         let original = AVURLAsset(url: media.url)
         let origV = try? await original.loadTracks(withMediaType: .video).first
-        let origA = try? await original.loadTracks(withMediaType: .audio).first
+        let origA: AVAssetTrack? = nil
 
         // Load every chunk asset's tracks CONCURRENTLY (bounded), then insert
         // in order. The old one-await-per-chunk loop made a media with
diff --git a/sequencer/Sources/Sequencer/ClipIndex.swift b/sequencer/Sources/Sequencer/ClipIndex.swift
new file mode 100644
index 0000000000000000000000000000000000000000..86db9b8e3495a93ddb0ad28887e090b9bf489f90
--- /dev/null
+++ b/sequencer/Sources/Sequencer/ClipIndex.swift
@@ -0,0 +1,169 @@
+import Foundation
+
+/// Derived lookup structures over one immutable `ProjectModel` snapshot.
+///
+/// `ProjectModel` keeps clips in a single flat array, so every playhead query
+/// (`clipAt`, "next cut", the audio window) is a full filter pass — and `Clip`
+/// is a fat value type (it inlines `Board`), so each pass COPIES every clip it
+/// touches. Those passes run at 60 Hz from half a dozen places (player sync,
+/// viewer cells, transport, subtitles), which on a big project is a constant
+/// drizzle of 100ms+ main-thread stalls (the hang log's
+/// `initializeWithCopy value witness for Sequencer.Clip` storms).
+///
+/// The index is built once per model change — O(n log n) — and answers the hot
+/// queries by binary search over per-lane arrays sorted by start. `Store.index`
+/// owns the caching: it hands out the same instance until the model changes.
+/// Never hold an index across a mutation; grab `store.index` fresh per use.
+final class ClipIndex {
+    /// One (track, kind) lane: clips sorted by start, plus a running maximum of
+    /// `end` over the prefix — the classic trick that lets a backward walk from
+    /// the binary-searched insertion point stop as soon as no earlier clip can
+    /// still overlap the query time.
+    private struct Lane {
+        var clips: [Clip] = []
+        var maxEnd: [Double] = []
+    }
+    private struct LaneKey: Hashable {
+        var track: TrackRef
+        var kind: ClipKind
+    }
+
+    private var lanes: [LaneKey: Lane] = [:]
+    /// Every clip that produces sound at the playhead, across ALL tracks:
+    /// audio clips, plus video clips whose media has an audio stream. Sorted by
+    /// start with the same max-end prefix; feeds the audio-player window.
+    private var audible = Lane()
+    private let mediaById: [UUID: MediaItem]
+    let laneRefs: [TrackRef]
+
+    init(_ project: ProjectModel) {
+        mediaById = Dictionary(uniqueKeysWithValues: project.media.map { ($0.id, $0) })
+        laneRefs = project.laneRefs
+        var groups: [LaneKey: [Clip]] = [:]
+        var audibleClips: [Clip] = []
+        for clip in project.clips {
+            groups[LaneKey(track: clip.track, kind: clip.kind), default: []].append(clip)
+            switch clip.kind {
+            case .audio:
+                audibleClips.append(clip)
+            case .video:
+                if let m = mediaById[clip.mediaId ?? UUID()], m.hasAudio {
+                    audibleClips.append(clip)
+                }
+            default:
+                break
+            }
+        }
+        for (key, clips) in groups {
+            lanes[key] = Self.makeLane(clips)
+        }
+        audible = Self.makeLane(audibleClips)
+    }
+
+    private static func makeLane(_ clips: [Clip]) -> Lane {
+        var lane = Lane()
+        lane.clips = clips.sorted { $0.start < $1.start }
+        lane.maxEnd.reserveCapacity(lane.clips.count)
+        var m = -Double.infinity
+        for c in lane.clips {
+            m = max(m, c.end)
+            lane.maxEnd.append(m)
+        }
+        return lane
+    }
+
+    func media(_ id: UUID?) -> MediaItem? { id.flatMap { mediaById[$0] } }
+
+    /// First index whose clip starts AFTER `t` (upper bound).
+    private static func upperBound(_ lane: Lane, _ t: Double) -> Int {
+        var lo = 0, hi = lane.clips.count
+        while lo < hi {
+            let mid = (lo + hi) / 2
+            if lane.clips[mid].start <= t { lo = mid + 1 } else { hi = mid }
+        }
+        return lo
+    }
+
+    /// Clip under `time` on a lane; when clips overlap, the latest start wins —
+    /// identical semantics to `ProjectModel.clipAt`.
+    func clipAt(track ref: TrackRef, time: Double, kind: ClipKind) -> Clip? {
+        guard let lane = lanes[LaneKey(track: ref, kind: kind)] else { return nil }
+        var i = Self.upperBound(lane, time) - 1
+        var best: Int?
+        while i >= 0, lane.maxEnd[i] > time {
+            if lane.clips[i].end > time {
+                // Matching the model's `max(by:)` exactly: among equal starts
+                // the FIRST in model order wins, and the sort is stable — so
+                // keep walking left through the tie group.
+                if let b = best, lane.clips[i].start < lane.clips[b].start { break }
+                best = i
+            }
+            i -= 1
+        }
+        return best.map { lane.clips[$0] }
+    }
+
+    /// Clips on a (track, kind) lane sorted by start. Returns the cached array
+    /// (CoW-shared, no copy).
+    func clips(on ref: TrackRef, kind: ClipKind) -> [Clip] {
+        lanes[LaneKey(track: ref, kind: kind)]?.clips ?? []
+    }
+
+    /// The next video clip on this track starting after `t` whose media differs
+    /// — the next cut a forward playhead will cross that needs a fresh player.
+    func nextDifferentClip(on ref: TrackRef, after t: Double,
+                           currentMedia: UUID?) -> Clip? {
+        guard let lane = lanes[LaneKey(track: ref, kind: .video)] else { return nil }
+        var i = Self.upperBound(lane, t + 1e-6)
+        while i < lane.clips.count {
+            if lane.clips[i].mediaId != currentMedia { return lane.clips[i] }
+            i += 1
+        }
+        return nil
+    }
+
+    /// The mirror for reverse playback: the previous clip ENDING before `t`
+    /// whose media differs.
+    func prevDifferentClip(on ref: TrackRef, before t: Double,
+                           currentMedia: UUID?) -> Clip? {
+        guard let lane = lanes[LaneKey(track: ref, kind: .video)] else { return nil }
+        var best: Clip?
+        for c in lane.clips {
+            if c.start >= t { break }   // ends only grow more likely, but starts are sorted
+            if c.end < t + 1e-6, c.mediaId != currentMedia,
+               best.map({ c.end > $0.end }) ?? true {
+                best = c
+            }
+        }
+        return best
+    }
+
+    /// Video clips on `ref` with a start or end boundary within `radius` of
+    /// `time` — the cuts whose exact frames are worth warming.
+    func boundaryClips(on ref: TrackRef, near time: Double, radius: Double) -> [Clip] {
+        guard let lane = lanes[LaneKey(track: ref, kind: .video)] else { return [] }
+        var out: [Clip] = []
+        var i = Self.upperBound(lane, time + radius) - 1
+        while i >= 0, lane.maxEnd[i] > time - radius {
+            let c = lane.clips[i]
+            if abs(c.start - time) <= radius || abs(c.end - time) <= radius {
+                out.append(c)
+            }
+            i -= 1
+        }
+        return out
+    }
+
+    /// Every sound-producing clip (audio clips + video clips with audio) whose
+    /// span intersects `[from, to)` — the window the per-clip audio players
+    /// keep alive around the playhead.
+    func audibleClips(from: Double, to: Double) -> [Clip] {
+        var out: [Clip] = []
+        var i = Self.upperBound(audible, to) - 1
+        while i >= 0, audible.maxEnd[i] > from {
+            if audible.clips[i].end > from { out.append(audible.clips[i]) }
+            i -= 1
+        }
+        return out
+    }
+}
diff --git a/sequencer/Sources/Sequencer/Document.swift b/sequencer/Sources/Sequencer/Document.swift
index 8ae89db69b9e726aa8f0e9117d865bb535c5118d..eed8ff1d3c687ac01d5b7760ebf2c16b278d1060 100644
--- a/sequencer/Sources/Sequencer/Document.swift
+++ b/sequencer/Sources/Sequencer/Document.swift
@@ -156,6 +156,19 @@ final class ProjectDocument: NSDocument {
             storyboard.preferredFilename = "Storyboard"
             root.addFileWrapper(storyboard)
         }
+        // REAPER export bakes audio stems into the package's `Stems/` folder,
+        // and REAPER renders the mixdown into `Render/`. The package is
+        // rewritten wholesale on every (auto)save, so re-attach the existing
+        // folders lazily or they would be wiped — and this way they travel
+        // with Save As / Duplicate.
+        for folder in ["Stems", "Render"] {
+            if let existing = fileURL?.appendingPathComponent(folder, isDirectory: true),
+               FileManager.default.fileExists(atPath: existing.path),
+               let wrapper = try? FileWrapper(url: existing, options: []) {
+                wrapper.preferredFilename = folder
+                root.addFileWrapper(wrapper)
+            }
+        }
         return root
     }
 }
diff --git a/sequencer/Sources/Sequencer/DocumentContext.swift b/sequencer/Sources/Sequencer/DocumentContext.swift
index 312719d32e18e333e9530d9f939f083508cbf433..14d6c82061c7232f5acb9d66f8b3bb8c912f4623 100644
--- a/sequencer/Sources/Sequencer/DocumentContext.swift
+++ b/sequencer/Sources/Sequencer/DocumentContext.swift
@@ -80,6 +80,10 @@ final class DocumentContext {
         // disk (reconcile) so the incremental ledger can't drift for long.
         MediaPipeline.shared.evictIfNeeded(reconcile: true)
         MediaPipeline.shared.ensureDerivedAssets(for: store.project)
+        // Prewarm the network-mount answers for this project's media so the
+        // first chunk scan reads them from cache — the statfs itself must
+        // never run on main (a cold NAS mount blocks it for seconds).
+        for m in store.project.media { _ = ChunkManager.cachedIsNetworkPath(m.path) }
         // NOTE: the whole-project proxy pre-build (`chunks.ensure`) is NOT kicked
         // here. macOS state restoration reopens *every* previously-open project on
         // launch, and each one running `ensure` would transcode its full ProRes
@@ -106,10 +110,12 @@ final class DocumentContext {
         // guard it so callers on the build path can ask "am I frontmost?" without
         // crashing — with no app, the headless context is by definition current.
         guard let app = NSApp else { return headless }
-        if let wc = app.keyWindow?.windowController as? SequencerWindowController {
+        // Any timeline-hosting window (main or an extra timeline window) resolves
+        // to its document's context.
+        if let wc = app.keyWindow?.windowController as? TimelineHostWindowController {
             return wc.ctx
         }
-        if let wc = app.mainWindow?.windowController as? SequencerWindowController {
+        if let wc = app.mainWindow?.windowController as? TimelineHostWindowController {
             return wc.ctx
         }
         if let doc = NSDocumentController.shared.currentDocument as? ProjectDocument {
diff --git a/sequencer/Sources/Sequencer/Export.swift b/sequencer/Sources/Sequencer/Export.swift
index fc93543fac46c600326219d27303b0d37cec6fc3..d1cabc89223a0be6e5fbba90304b336dd1220deb 100644
--- a/sequencer/Sources/Sequencer/Export.swift
+++ b/sequencer/Sources/Sequencer/Export.swift
@@ -176,6 +176,9 @@ struct ExportJob {
     var resolution: ExportResolution
     var fps: Double
     var dest: URL
+    /// Lay the REAPER sidecar's audio under a `.tracks` export (the rendered
+    /// mix when one exists, else the raw stems). The dialog's checkbox.
+    var includeReaper = true
 }
 
 // MARK: - Exporter
@@ -234,15 +237,31 @@ enum Exporter {
 
     private static func exportTracks(_ job: ExportJob, video: [TrackRef], audio: Set<TrackRef>,
                                      progress: @escaping (Double) -> Void) throws {
-        let project = DocumentContext.current.store.project
+        let ctx = DocumentContext.current
+        let project = ctx.store.project
         let segments = ExportPlan.flattenTopmost(project: project, trackRefs: video)
-        let audioClips = ExportPlan.audioClips(project: project, trackRefs: audio)
+        var audioClips = ExportPlan.audioClips(project: project, trackRefs: audio)
+
+        // REAPER sidecar audio joins every export: the rendered mixdown when
+        // one exists (that's the processed mix), otherwise the raw stems on
+        // the reaper lanes mix in like ordinary audio clips.
+        var mixdownURL: URL? = nil
+        if project.hasReaper, job.includeReaper {
+            if let u = ReaperLink.renderURL(ctx),
+               FileManager.default.fileExists(atPath: u.path) {
+                mixdownURL = u
+            } else {
+                let reaperRefs = Set(project.reaperTracks.indices.map { TrackRef.reaper($0) })
+                audioClips += ExportPlan.audioClips(project: project, trackRefs: reaperRefs)
+                    .filter { !$0.reaperGhost }
+            }
+        }
 
         if job.format.isVideo && segments.isEmpty {
             throw ExportError.nothingToExport(
                 "No video clips on the selected tracks for a video format.")
         }
-        if !job.format.isVideo && audioClips.isEmpty {
+        if !job.format.isVideo && audioClips.isEmpty && mixdownURL == nil {
             throw ExportError.nothingToExport(
                 "No audio on the selected tracks for an audio-only format.")
         }
@@ -306,17 +325,36 @@ enum Exporter {
                 aTrack.scaleTimeRange(cmRange(clip.start, srcDur), toDuration: cm(clip.duration))
             }
             let p = AVMutableAudioMixInputParameters(track: aTrack)
+            // Clip volume: baseline for the whole clip, and the fades ramp
+            // to/from it rather than unity (unlike live playback, the export
+            // mix honors boost gains > 1).
+            let gain = Float(max(0, clip.gain))
+            if abs(gain - 1) > 0.001 { p.setVolume(gain, at: cm(clip.start)) }
             if clip.fadeIn > 0.001 {
-                p.setVolumeRamp(fromStartVolume: 0, toEndVolume: 1,
+                p.setVolumeRamp(fromStartVolume: 0, toEndVolume: gain,
                                 timeRange: cmRange(clip.start, clip.fadeIn))
             }
             if clip.fadeOut > 0.001 {
-                p.setVolumeRamp(fromStartVolume: 1, toEndVolume: 0,
+                p.setVolumeRamp(fromStartVolume: gain, toEndVolume: 0,
                                 timeRange: cmRange(clip.end - clip.fadeOut, clip.fadeOut))
             }
             mixParams.append(p)
         }
 
+        // The REAPER mixdown lays under everything at t=0, full length, unity
+        // gain — level/fades were already baked by REAPER's own render.
+        if let mixdownURL,
+           let aTrack = comp.addMutableTrack(
+            withMediaType: .audio, preferredTrackID: kCMPersistentTrackID_Invalid) {
+            let asset = AVURLAsset(url: mixdownURL)
+            if let src = loadTracksSync(asset, mediaType: .audio).first {
+                do { try aTrack.insertTimeRange(src.timeRange, of: src, at: .zero) }
+                catch { missing.insert("Render/mix.wav") }
+            } else {
+                missing.insert("Render/mix.wav")
+            }
+        }
+
         // Any unreadable source means the render would be silently truncated —
         // stop and tell the user exactly which files, rather than produce a
         // partial export that looks complete.
diff --git a/sequencer/Sources/Sequencer/ExportDialog.swift b/sequencer/Sources/Sequencer/ExportDialog.swift
index 45224e4159411d3b058b2e01b4c3ff23b904d279..fa4e28aca28ee4f84b4a56065c4e515de4ee2242 100644
--- a/sequencer/Sources/Sequencer/ExportDialog.swift
+++ b/sequencer/Sources/Sequencer/ExportDialog.swift
@@ -10,6 +10,7 @@ final class ExportDialog: NSObject {
     private var trackRows: [(index: Int, checkbox: NSButton)] = []
     private var fusionCheckbox: NSButton?
     private var storyboardCheckbox: NSButton?
+    private var reaperCheckbox: NSButton?
     private let formatPopup = NSPopUpButton()
     private let resolutionPopup = NSPopUpButton()
     private let hud = ExportProgressHUD()
@@ -30,10 +31,11 @@ final class ExportDialog: NSObject {
         trackRows = []
         fusionCheckbox = nil
         storyboardCheckbox = nil
+        reaperCheckbox = nil
 
         let w = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 420, height: 400),
                          styleMask: [.titled, .closable], backing: .buffered, defer: false)
-        w.title = "Export"
+        w.title = "Export Media"
         w.isReleasedWhenClosed = false
 
         let root = NSStackView()
@@ -78,6 +80,22 @@ final class ExportDialog: NSObject {
             storyboardCheckbox = cb
         }
 
+        // The REAPER sidecar's audio: the rendered mix when one exists, the
+        // raw stems otherwise. On by default — it's the project's sound bed.
+        if project.hasReaper {
+            let mixReady = ReaperLink.renderURL(DocumentContext.current)
+                .map { FileManager.default.fileExists(atPath: $0.path) } ?? false
+            let cb = NSButton(
+                checkboxWithTitle: mixReady ? "REAPER audio (rendered mix)"
+                                            : "REAPER audio (stems — no render yet)",
+                target: self, action: #selector(trackToggled))
+            cb.state = .on
+            let row = NSStackView(views: [colorSwatch(Theme.reaperGreen), cb])
+            row.spacing = 6
+            root.addArrangedSubview(row)
+            reaperCheckbox = cb
+        }
+
         // Regular track rows: only tracks that actually hold clips.
         for index in project.tracks.indices {
             let clips = project.clips(onVideo: index)
@@ -182,6 +200,8 @@ final class ExportDialog: NSObject {
             cb.isEnabled = !special
             if special { cb.state = .off }
         }
+        reaperCheckbox?.isEnabled = !special
+        if special { reaperCheckbox?.state = .off }
         fusionCheckbox?.isEnabled = !storyOn
         storyboardCheckbox?.isEnabled = !fusionOn
         let f = ExportFormat.allCases[formatPopup.indexOfSelectedItem]
@@ -195,13 +215,16 @@ final class ExportDialog: NSObject {
         let resolution = ExportResolution.allCases[resolutionPopup.indexOfSelectedItem]
 
         let source: ExportJob.Source
+        var includeReaper = false
         if fusionCheckbox?.state == .on {
             source = .fusion
         } else if storyboardCheckbox?.state == .on {
             source = .storyboard
         } else {
+            includeReaper = reaperCheckbox?.state == .on
             let checked = trackRows.filter { $0.checkbox.state == .on }.map(\.index)
-            guard !checked.isEmpty else {
+            // REAPER audio alone is a valid (audio-only) export.
+            guard !checked.isEmpty || includeReaper else {
                 alert("Select at least one track to export."); return
             }
             let ordered = checked.sorted().map { TrackRef.video($0) }
@@ -214,8 +237,9 @@ final class ExportDialog: NSObject {
         save.canCreateDirectories = true
         guard save.runModal() == .OK, let dest = save.url else { return }
 
-        let job = ExportJob(source: source, format: format, resolution: resolution,
+        var job = ExportJob(source: source, format: format, resolution: resolution,
                             fps: project.fps, dest: dest)
+        job.includeReaper = includeReaper
         window?.close()
         hud.begin(title: "Exporting \(dest.lastPathComponent)")
         Exporter.run(job, progress: { [hud] f in hud.setFraction(f) }) { [hud] result in
diff --git a/sequencer/Sources/Sequencer/FrameCache.swift b/sequencer/Sources/Sequencer/FrameCache.swift
index 47b0bf406d646f151a4e4c2c3e545f5455f1df9c..386f8ee62e6aac50e5f30c9a1fb2638f1d56c3c2 100644
--- a/sequencer/Sources/Sequencer/FrameCache.swift
+++ b/sequencer/Sources/Sequencer/FrameCache.swift
@@ -18,6 +18,16 @@ import QuartzCore
 /// hundred boundaries. Frames are keyed on 0.25s buckets — a stand-in a
 /// fraction of a second off is indistinguishable during the sub-second hold
 /// it covers.
+///
+/// Storage is a hand-rolled LRU (dictionary + intrusive use-order list), NOT
+/// an NSCache: NSCache's cost eviction is neither LRU nor recency-aware — at
+/// the cost limit it evicts in an unspecified order that in practice dumps
+/// the entries being inserted NOW (the segment the user is playing) while
+/// stale ones squat, and `object(forKey:)` does not refresh anything. Here a
+/// hit — a viewer display or a satisfied warm — moves the entry to the hot
+/// end, so eviction always eats the least-recently-USED frame and the
+/// playhead's neighborhood survives a full cache. Main-thread only (every
+/// caller already is; decodes hop back via main.async).
 final class FrameCache {
     static let shared = FrameCache()
     private static let bucket = 0.25
@@ -27,7 +37,36 @@ final class FrameCache {
         return gb > 0 ? gb : 2
     }
 
-    private let cache = NSCache<NSString, CGImage>()
+    /// `atTarget` records whether the frame was decoded from a full-tier
+    /// source (target-width chunk / legacy proxy / original) or a reduced one
+    /// (below-target chunk, rescue slice).
+    private final class Entry {
+        let key: String
+        let mediaKey: String
+        let bucket: Int
+        let image: CGImage
+        let atTarget: Bool
+        let cost: Int
+        // Intrusive use-order list: head = hottest, tail = next to evict.
+        var hotter: Entry?
+        var colder: Entry?
+        init(key: String, mediaKey: String, bucket: Int, image: CGImage,
+             atTarget: Bool, cost: Int) {
+            self.key = key; self.mediaKey = mediaKey; self.bucket = bucket
+            self.image = image; self.atTarget = atTarget; self.cost = cost
+        }
+    }
+
+    private var entries: [String: Entry] = [:]
+    private var head: Entry?          // most recently used
+    private var tail: Entry?          // least recently used
+    private var totalCost = 0
+    private var costLimit = 0
+    /// Which 0.25s buckets are resident (and at what tier), per media — the
+    /// timeline's RAM indicator reads this ledger (kept in sync by `install`
+    /// and eviction). Value = decoded from a full-tier source.
+    private var resident: [String: [Int: Bool]] = [:]
+    private var residencyPostPending = false
     /// Decodes in flight / recently failed (source vanished mid-decode, or a
     /// truncated file) — failures back off so a hopeless frame isn't retried
     /// every tick. Main-thread only.
@@ -35,32 +74,156 @@ final class FrameCache {
     private var failedAt: [String: Double] = [:]
     private let genQueue = DispatchQueue(label: "sequencer.framecache",
                                          qos: .userInitiated)
+    private var pressureSource: DispatchSourceMemoryPressure?
 
-    init() { refreshBudget() }
+    init() {
+        refreshBudget()
+        // NSCache used to shed under system memory pressure for free; keep
+        // that courtesy — these are re-decodable stand-ins, not state.
+        let src = DispatchSource.makeMemoryPressureSource(
+            eventMask: [.warning, .critical], queue: .main)
+        src.setEventHandler { [weak self] in
+            guard let self else { return }
+            if self.pressureSource?.data.contains(.critical) == true {
+                self.removeAll()
+            } else {
+                self.evict(toFit: self.costLimit / 2)
+            }
+        }
+        pressureSource = src
+        src.activate()
+    }
 
     /// Re-read the budget after the Settings field changes.
     func refreshBudget() {
-        cache.totalCostLimit = Self.ramGB * 1_000_000_000
+        costLimit = Self.ramGB * 1_000_000_000
+        evict(toFit: costLimit)
     }
 
-    private func key(_ mediaKey: String, bucket: Int) -> NSString {
-        "\(mediaKey)@\(bucket)" as NSString
+    private func key(_ mediaKey: String, bucket: Int) -> String {
+        "\(mediaKey)@\(bucket)"
     }
     private func bucketIndex(_ src: Double) -> Int {
         Int((src / Self.bucket).rounded())
     }
 
+    // MARK: - Use-order list
+
+    private func unlink(_ e: Entry) {
+        if head === e { head = e.colder }
+        if tail === e { tail = e.hotter }
+        e.hotter?.colder = e.colder
+        e.colder?.hotter = e.hotter
+        e.hotter = nil; e.colder = nil
+    }
+
+    /// Mark `e` as just-used: move it to the hot end of the eviction order.
+    private func touch(_ e: Entry) {
+        guard head !== e else { return }
+        unlink(e)
+        e.colder = head
+        head?.hotter = e
+        head = e
+        if tail == nil { tail = e }
+    }
+
+    /// Evict coldest-first until the ledger fits `limit`. `keep` (the entry
+    /// being installed right now) is never a victim — inserting at the limit
+    /// must displace something OLD, not bounce the new frame (that exact
+    /// behavior, in NSCache, made the playing segment evict itself).
+    private func evict(toFit limit: Int, keeping keep: Entry? = nil) {
+        while totalCost > limit, let victim = tail, victim !== keep {
+            remove(victim)
+        }
+    }
+
+    private func remove(_ e: Entry) {
+        unlink(e)
+        entries.removeValue(forKey: e.key)
+        totalCost -= e.cost
+        resident[e.mediaKey]?.removeValue(forKey: e.bucket)
+        if resident[e.mediaKey]?.isEmpty == true {
+            resident.removeValue(forKey: e.mediaKey)
+        }
+        noteResidencyChanged()
+    }
+
+    private func removeAll() {
+        entries.removeAll()
+        head = nil; tail = nil
+        totalCost = 0
+        if !resident.isEmpty {
+            resident.removeAll()
+            noteResidencyChanged()
+        }
+    }
+
+    // MARK: - Lookup
+
     /// The cached frame nearest `src`, if any (this bucket or a neighbor).
+    /// A hit counts as a use — the frame on screen is the last one eviction
+    /// should take.
     func image(media: MediaItem, at src: Double) -> CGImage? {
         let b = bucketIndex(src)
         for d in [0, -1, 1] {
-            if let img = cache.object(forKey: key(media.cacheKey, bucket: b + d)) {
-                return img
+            if let e = entries[key(media.cacheKey, bucket: b + d)] {
+                touch(e)
+                return e.image
             }
         }
         return nil
     }
 
+    /// The tier of the RAM frame a seek to `src` would find (same ±1-bucket
+    /// lookup order as `image`): nil = none, true = decoded from a full-tier
+    /// source, false = from a reduced one. Ledger lookup only — cheap enough
+    /// for the timeline strip to call per column, and deliberately NOT a
+    /// "use" (painting the strip must not scramble the eviction order).
+    /// Main-thread.
+    func residentQuality(mediaKey: String, at src: Double) -> Bool? {
+        guard let buckets = resident[mediaKey] else { return nil }
+        let b = bucketIndex(src)
+        for d in [0, -1, 1] {
+            if let q = buckets[b + d] { return q }
+        }
+        return nil
+    }
+
+    /// Test hooks (--uitest): drive install/evict without a real decode.
+    func installForTest(_ img: CGImage, mediaKey: String, at src: Double, atTarget: Bool) {
+        install(img, mediaKey: mediaKey, bucket: bucketIndex(src), atTarget: atTarget)
+    }
+    func removeAllForTest() { removeAll() }
+    func setBudgetForTest(bytes: Int) { costLimit = bytes; evict(toFit: bytes) }
+
+    // MARK: - Install / decode
+
+    /// Book a decoded frame into the cache + residency ledger. Main-thread.
+    private func install(_ img: CGImage, mediaKey: String, bucket: Int, atTarget: Bool) {
+        let k = key(mediaKey, bucket: bucket)
+        if let old = entries[k] { remove(old) }   // tier upgrade re-install
+        let e = Entry(key: k, mediaKey: mediaKey, bucket: bucket, image: img,
+                      atTarget: atTarget, cost: img.bytesPerRow * img.height)
+        entries[k] = e
+        totalCost += e.cost
+        touch(e)
+        evict(toFit: costLimit, keeping: e)
+        resident[mediaKey, default: [:]][bucket] = atTarget
+        noteResidencyChanged()
+    }
+
+    /// The strip reads residency at draw time; tell it to recompute. Coalesced
+    /// to one post per runloop turn — evictions come in storms.
+    private func noteResidencyChanged() {
+        guard !residencyPostPending else { return }
+        residencyPostPending = true
+        DispatchQueue.main.async {
+            self.residencyPostPending = false
+            // No "scene" key: repaint + strip recompute, no tile flush.
+            NotificationCenter.default.post(name: .mediaStatusChanged, object: nil)
+        }
+    }
+
     /// Decode the frame at `src` into the cache if it isn't there already.
     /// `source` is a playable (file, time-in-file) pair for this moment,
     /// resolved on the main thread by `ChunkManager.frameSource` — nil (no
@@ -70,11 +233,20 @@ final class FrameCache {
     /// `SEQ_NOWARM=1` disables decodes (diagnostic kill switch).
     private static let disabled = ProcessInfo.processInfo.environment["SEQ_NOWARM"] != nil
 
-    func warm(mediaKey: String, at src: Double, source: (url: URL, time: Double)?) {
+    func warm(mediaKey: String, at src: Double,
+              source: (url: URL, time: Double, atTarget: Bool)?) {
         guard !Self.disabled, let source else { return }
-        let k = key(mediaKey, bucket: bucketIndex(src))
-        let ks = k as String
-        guard cache.object(forKey: k) == nil, !inFlight.contains(ks) else { return }
+        let bucket = bucketIndex(src)
+        let ks = key(mediaKey, bucket: bucket)
+        // A cached frame satisfies the warm — unless it was decoded from a
+        // reduced-tier source and a full-tier one is available now: re-decode
+        // so the stand-in (and the strip's RAM tier) heals upward. A satisfied
+        // warm is a use: the playhead sweeping a warmed span keeps it hot.
+        if let existing = entries[ks], existing.atTarget || !source.atTarget {
+            touch(existing)
+            return
+        }
+        guard !inFlight.contains(ks) else { return }
         let now = CACurrentMediaTime()
         if let failed = failedAt[ks], now - failed < 5 { return }
         inFlight.insert(ks)
@@ -82,6 +254,11 @@ final class FrameCache {
             let asset = AVURLAsset(url: source.url)
             let gen = AVAssetImageGenerator(asset: asset)
             gen.appliesPreferredTrackTransform = true
+            // Stand-ins never need more than proxy resolution: a native 4K
+            // decode is ~33 MB of BGRA that the render server then has to
+            // upload as a texture mid-playback (the CABackingStore [hang]s),
+            // and it quarters how many frames the RAM budget holds.
+            gen.maximumSize = CGSize(width: 1920, height: 1920)
             // Exact going in, a hair of slack after: the frame ON the cut is
             // what a boundary needs, but a keyframe-snap decode is far cheaper
             // than a precise reverse walk.
@@ -93,8 +270,8 @@ final class FrameCache {
                 self.inFlight.remove(ks)
                 if let img {
                     self.failedAt.removeValue(forKey: ks)
-                    self.cache.setObject(img, forKey: k,
-                                         cost: img.bytesPerRow * img.height)
+                    self.install(img, mediaKey: mediaKey, bucket: bucket,
+                                 atTarget: source.atTarget)
                     NotificationCenter.default.post(name: .viewerNeedsRefresh,
                                                     object: nil)
                 } else {
diff --git a/sequencer/Sources/Sequencer/MediaPipeline.swift b/sequencer/Sources/Sequencer/MediaPipeline.swift
index 4a89a14956238f1d6dcf6a962b749fcd1d088ae0..04d5f8e657ee05090dcb131da0f05b5c7cce1b13 100644
--- a/sequencer/Sources/Sequencer/MediaPipeline.swift
+++ b/sequencer/Sources/Sequencer/MediaPipeline.swift
@@ -10,6 +10,30 @@ struct MediaStatus {
     var failed: String? = nil
 }
 
+/// A Reaper-`reapeaks`-style multi-resolution waveform: min/max amplitude
+/// buckets at successive ×2 halvings. Level 0 is the base resolution
+/// (`baseBucketDur` seconds per bucket); each higher level halves the bucket
+/// count. The draw path picks the level giving ~1–2 buckets per on-screen
+/// pixel and reads min/max straight out, so a waveform is sharp at ANY zoom
+/// from a single cached file — no per-frame full-resolution scan, no stretched
+/// bitmap. Amplitudes are Int8 (−127…127), two bytes per bucket.
+final class PeakData {
+    let baseBucketDur: Double     // seconds per level-0 bucket
+    let levels: [[Int8]]          // per level: [min0, max0, min1, max1, …]
+    init(baseBucketDur: Double, levels: [[Int8]]) {
+        self.baseBucketDur = baseBucketDur
+        self.levels = levels
+    }
+    /// Level whose buckets are ≥ `srcSecPerPixel / targetPerPixel` wide — i.e.
+    /// aggregating it costs ~`targetPerPixel` buckets per drawn column.
+    func level(forSrcSecPerPixel s: Double, targetPerPixel: Double = 1.5) -> Int {
+        var level = 0, dur = baseBucketDur
+        while level + 1 < levels.count && s / dur > targetPerPixel { level += 1; dur *= 2 }
+        return level
+    }
+    func bucketDur(_ level: Int) -> Double { baseBucketDur * Double(1 << level) }
+}
+
 /// ffprobe/ffmpeg-based derived-media pipeline: probe, filmstrip, ProRes
 /// proxy. Cache is content-addressed and LRU-capped so NAS media gets a
 /// bounded local working set.
@@ -26,10 +50,19 @@ final class MediaPipeline {
 
     private let ffmpeg: String?
     private let ffprobe: String?
-    private let workQueue = OperationQueue()
+    /// Viewport-driven work (coarse strips + peaks + fine windows for media
+    /// currently on screen). Higher QoS and more slots than the background fill,
+    /// so what you're looking at builds first even while distant media churn.
+    private let demandQueue = OperationQueue()
+    /// Whole-project background fill for media nobody is looking at yet — one at
+    /// a time at low QoS, so it never starves or contends with demand work.
+    private let bgQueue = OperationQueue()
     private var statuses: [UUID: MediaStatus] = [:] // main-thread only
     private let thumbCache = NSCache<NSString, CGImage>()
-    private var stripInfoCache: [String: (interval: Double, count: Int)] = [:]
+    /// Sorted source-second timestamp of each coarse (keyframe) thumbnail
+    /// `%06d.jpg` (1-based) — keyframes are irregularly spaced, so the draw path
+    /// binary-searches this for the nearest.
+    private var stripInfoCache: [String: [Double]] = [:]
     private var lruTouched: [String: Date] = [:]
 
     init() {
@@ -42,7 +75,14 @@ final class MediaPipeline {
         try? FileManager.default.createDirectory(at: cacheRoot, withIntermediateDirectories: true)
         ffmpeg = Self.findExecutable("ffmpeg")
         ffprobe = Self.findExecutable("ffprobe")
-        workQueue.maxConcurrentOperationCount = 2
+        demandQueue.maxConcurrentOperationCount = 2
+        demandQueue.qualityOfService = .userInitiated
+        bgQueue.maxConcurrentOperationCount = 1
+        bgQueue.qualityOfService = .utility
+        audioQueue.maxConcurrentOperationCount = 2
+        audioQueue.qualityOfService = .userInitiated
+        try? FileManager.default.createDirectory(at: audioRoot,
+                                                 withIntermediateDirectories: true)
         thumbCache.countLimit = 2000
         // A previous instance killed mid-build (rebuild relaunch, force quit)
         // leaves orphaned ffmpeg encoders holding shared VideoToolbox decode
@@ -75,15 +115,35 @@ final class MediaPipeline {
     }
 
     private var offlineCache: [String: (offline: Bool, until: Date)] = [:] // main-thread only
+    private var offlineChecking = Set<String>()                            // main-thread only
+    private let offlineQueue = DispatchQueue(label: "sequencer.offline", qos: .utility)
     /// Whether the media's ORIGINAL file is currently unreachable (moved, or on
-    /// an unmounted NAS). Cached briefly so the viewer can call it every frame
-    /// without a `stat` each time, and so it auto-recovers when the drive returns.
+    /// an unmounted NAS). Stale-while-revalidate: always answers from cache
+    /// instantly (assuming online until known otherwise) and refreshes with a
+    /// BACKGROUND stat — a synchronous stat of a cold NAS volume can block the
+    /// main thread for seconds (the hang log caught exactly that, per viewer
+    /// cell per tick).
     func isOffline(_ media: MediaItem) -> Bool {
-        let now = Date()
-        if let c = offlineCache[media.cacheKey], c.until > now { return c.offline }
-        let off = !FileManager.default.fileExists(atPath: media.path)
-        offlineCache[media.cacheKey] = (off, now.addingTimeInterval(2))
-        return off
+        let key = media.cacheKey
+        let cached = offlineCache[key]
+        if let cached, cached.until > Date() { return cached.offline }
+        if !offlineChecking.contains(key) {
+            offlineChecking.insert(key)
+            let path = media.path
+            offlineQueue.async {
+                let off = !FileManager.default.fileExists(atPath: path)
+                DispatchQueue.main.async {
+                    self.offlineChecking.remove(key)
+                    let flipped = self.offlineCache[key]?.offline != off
+                    self.offlineCache[key] = (off, Date().addingTimeInterval(2))
+                    if flipped {
+                        NotificationCenter.default.post(name: .mediaStatusChanged,
+                                                        object: nil)
+                    }
+                }
+            }
+        }
+        return cached?.offline ?? false
     }
 
     // MARK: - Cache paths
@@ -111,9 +171,9 @@ final class MediaPipeline {
     private func keyDir(_ key: String) -> URL {
         cacheRoot.appendingPathComponent(sanitizedKey(key), isDirectory: true)
     }
-    private func proxyFileURL(_ key: String) -> URL { keyDir(key).appendingPathComponent("proxy.mov") }
+    private func proxyFileURL(_ key: String) -> URL { keyDir(key).appendingPathComponent("proxy.mov", isDirectory: false) }
     private func stripDir(_ key: String) -> URL { keyDir(key).appendingPathComponent("strip", isDirectory: true) }
-    private func stripInfoURL(_ key: String) -> URL { stripDir(key).appendingPathComponent("info.json") }
+    private func stripInfoURL(_ key: String) -> URL { stripDir(key).appendingPathComponent("info.json", isDirectory: false) }
 
     static func cacheKey(for url: URL) -> String {
         let attrs = try? FileManager.default.attributesOfItem(atPath: url.path)
@@ -134,17 +194,170 @@ final class MediaPipeline {
         return Self.hashedKey("path|\(media.path)")
     }
 
-    /// Proxy URL if the proxy exists (touches LRU).
+    private var proxyExistsCache: [String: (exists: Bool, until: Date)] = [:] // main-thread only
+    /// Proxy URL if the (legacy whole-file) proxy exists (touches LRU). The
+    /// existence stat is memoized briefly: this runs per player-sync tick and
+    /// per stand-in decode, and the watchdog caught the bare fileExists
+    /// stalling the main thread.
     func proxyURL(for media: MediaItem) -> URL? {
-        let url = proxyFileURL(media.cacheKey)
-        guard FileManager.default.fileExists(atPath: url.path) else { return nil }
-        touchLRU(media.cacheKey)
-        return url
+        let key = media.cacheKey
+        let now = Date()
+        let exists: Bool
+        if let c = proxyExistsCache[key], c.until > now {
+            exists = c.exists
+        } else {
+            exists = FileManager.default.fileExists(atPath: proxyFileURL(key).path)
+            proxyExistsCache[key] = (exists, now.addingTimeInterval(5))
+        }
+        guard exists else { return nil }
+        touchLRU(key)
+        return proxyFileURL(key)
     }
 
     // MARK: - Import
 
     /// Probe a file and kick off background filmstrip + proxy generation.
+    // MARK: - Audio proxies (separate budget, built before everything else)
+
+    /// Local audio-only extractions (`_audio/<key>.mov`, stream-copied when the
+    /// codec allows, AAC otherwise) of every sound-bearing media file. Playback
+    /// audio reads ORIGINALS (see AudioAssetCache) — which live on the NAS,
+    /// where video chunk encodes are hammering the same volume; that contention
+    /// is when audio stutters. Audio is tiny next to video (~100 MB/hour vs
+    /// ~700 MB/minute of ProRes proxy), so it gets its OWN budget
+    /// (`maxAudioCacheGB`, default 8 — video pressure can never evict it) and
+    /// absolute build priority: extraction starts at document open and the
+    /// chunk background fill yields until every audio proxy is local.
+    private var audioRoot: URL {
+        cacheRoot.appendingPathComponent("_audio", isDirectory: true)
+    }
+    /// The audio subroot must be invisible to the VIDEO cache machinery: it is
+    /// skipped by whole-dir eviction and subtracted from the chunk ledger.
+    static let audioDirName = "_audio"
+
+    var maxAudioCacheBytes: Int64 {
+        let gb = UserDefaults.standard.integer(forKey: "maxAudioCacheGB")
+        return Int64(gb > 0 ? gb : 8) * 1_000_000_000
+    }
+
+    private let audioQueue = OperationQueue()
+    private var audioExistsCache: [String: (exists: Bool, until: Date)] = [:] // main-thread
+    /// Keys queued or extracting — the chunk fill yields while any of the
+    /// front project's keys are in here. Main-thread only.
+    private(set) var audioPending = Set<String>()
+    private var audioFailedAt: [String: Date] = [:]   // main-thread; retry backoff
+
+    private func audioProxyFileURL(_ key: String) -> URL {
+        audioRoot.appendingPathComponent("\(key).mov", isDirectory: false)
+    }
+
+    /// The local audio proxy for this media, if extraction has landed.
+    /// Existence memoized 5s (per-tick callers must not stat). Main-thread.
+    func audioProxyURL(for media: MediaItem) -> URL? {
+        let key = media.cacheKey
+        let now = Date()
+        let url = audioProxyFileURL(key)
+        if let c = audioExistsCache[key], c.until > now {
+            return c.exists ? url : nil
+        }
+        let exists = FileManager.default.fileExists(atPath: url.path)
+        audioExistsCache[key] = (exists, now.addingTimeInterval(5))
+        return exists ? url : nil
+    }
+
+    /// Queue the audio extraction for this media if it has sound and no proxy
+    /// yet. Idempotent per session; failures back off 60s (an unmounted NAS
+    /// must not hot-loop ffmpeg). Main-thread.
+    func ensureAudioProxy(for media: MediaItem) {
+        guard ffmpeg != nil, media.hasAudio || media.isAudio else { return }
+        let key = media.cacheKey
+        guard !audioPending.contains(key), audioProxyURL(for: media) == nil else { return }
+        if let f = audioFailedAt[key], Date().timeIntervalSince(f) < 60 { return }
+        audioPending.insert(key)
+        audioQueue.addOperation { self.extractAudioProxy(media) }
+    }
+
+    /// True while any of this project's audio proxies are still queued or
+    /// extracting — the signal the chunk background fill yields on. Main-thread.
+    func audioProxiesPending(for project: ProjectModel) -> Bool {
+        !audioPending.isEmpty
+            && project.media.contains { audioPending.contains($0.cacheKey) }
+    }
+
+    private func extractAudioProxy(_ media: MediaItem) {
+        guard let ffmpeg else { return }
+        let key = media.cacheKey
+        let dst = audioProxyFileURL(key)
+        let tmp = audioRoot.appendingPathComponent("\(key).building.mov",
+                                                   isDirectory: false)
+        let fm = FileManager.default
+        try? fm.removeItem(at: tmp)
+        // Stream copy first — reads only the audio packets (mov chunk tables
+        // let the demuxer skip video bytes, so a huge 4K file costs roughly
+        // its audio size in NAS reads). Codecs a .mov can't hold, or that
+        // AVFoundation can't play, fall back to an AAC transcode.
+        let base = ["-nostdin", "-v", "error", "-y", "-i", media.path,
+                    "-vn", "-sn", "-dn", "-map", "0:a:0"]
+        var ok = Self.run(ffmpeg, base + ["-c:a", "copy",
+                                          "-movflags", "+faststart", tmp.path])
+            .exitCode == 0
+        if !ok {
+            try? fm.removeItem(at: tmp)
+            ok = Self.run(ffmpeg, base + ["-c:a", "aac", "-b:a", "256k",
+                                          "-movflags", "+faststart", tmp.path])
+                .exitCode == 0
+        }
+        if ok { try? fm.removeItem(at: dst); ok = (try? fm.moveItem(at: tmp, to: dst)) != nil }
+        if !ok { try? fm.removeItem(at: tmp) }
+        let bytes = ok ? ((try? fm.attributesOfItem(atPath: dst.path)[.size]
+                            as? NSNumber)?.int64Value ?? 0) : 0
+        evictAudioIfNeeded()
+        DispatchQueue.main.async {
+            self.audioPending.remove(key)
+            self.audioExistsCache[key] = nil
+            if ok {
+                self.audioFailedAt.removeValue(forKey: key)
+                SeqLog.log("[cache] audio proxy \(key) landed (%.1f MB)",
+                           Double(bytes) / 1e6)
+                NotificationCenter.default.post(name: .mediaStatusChanged, object: nil)
+            } else {
+                self.audioFailedAt[key] = Date()
+                SeqLog.log("[cache] audio proxy \(key) FAILED (\(media.path))")
+            }
+            // The fill was yielding to this extraction; wake it.
+            for c in DocumentContext.allLive { c.chunks.budgetChanged() }
+        }
+    }
+
+    /// Enforce the audio cache's own cap: oldest-mtime proxies of keys no open
+    /// document references go first. Audio is small enough that this should
+    /// essentially never fire; it exists so the budget is a real ceiling.
+    /// Runs on the extraction queue.
+    private func evictAudioIfNeeded() {
+        let fm = FileManager.default
+        guard Self.directorySize(audioRoot) > maxAudioCacheBytes,
+              let files = try? fm.contentsOfDirectory(
+                  at: audioRoot, includingPropertiesForKeys:
+                      [.contentModificationDateKey, .fileSizeKey]) else { return }
+        let inUse = DispatchQueue.main.sync {
+            Set(DocumentContext.allLive.flatMap { $0.store.project.media.map(\.cacheKey) })
+        }
+        var over = Self.directorySize(audioRoot) - maxAudioCacheBytes
+        let byAge = files.sorted {
+            ((try? $0.resourceValues(forKeys: [.contentModificationDateKey])
+                .contentModificationDate) ?? .distantPast)
+            < ((try? $1.resourceValues(forKeys: [.contentModificationDateKey])
+                .contentModificationDate) ?? .distantPast)
+        }
+        for f in byAge where over > 0 {
+            let key = f.deletingPathExtension().lastPathComponent
+            guard !inUse.contains(key) else { continue }
+            let size = Int64((try? f.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
+            try? fm.removeItem(at: f)
+            over -= size
+        }
+    }
+
     func importFile(_ url: URL, completion: @escaping (MediaItem?) -> Void) {
         guard let ffprobe else {
             DispatchQueue.main.async {
@@ -222,57 +435,286 @@ final class MediaPipeline {
     }
 
     private var enqueued: Set<String> = []
+    // Media whose viewport (demand) job is already queued — so the draw path,
+    // which asks every frame, enqueues each visible media's strip/peaks once.
+    private var stripDemanded = Set<String>()
+    private var peaksDemanded = Set<String>()
 
     func enqueueDerivedAssets(for media: MediaItem) {
         guard ffmpeg != nil, !enqueued.contains(media.cacheKey) else { return }
         enqueued.insert(media.cacheKey)
+        // Audio first, always: the extraction queue starts immediately and the
+        // chunk background fill yields until every audio proxy is local.
+        ensureAudioProxy(for: media)
         if media.isAudio {
-            if !FileManager.default.fileExists(atPath: waveformURL(media.cacheKey).path) {
-                workQueue.addOperation { self.generateWaveform(media) }
+            if !FileManager.default.fileExists(atPath: peaksURL(media.cacheKey).path) {
+                bgQueue.addOperation { self.generatePeaks(media) }
             }
             return
         }
         let s = status(for: media)
-        if !s.filmstripReady { workQueue.addOperation { self.generateFilmstrip(media) } }
+        if !s.filmstripReady { bgQueue.addOperation { self.generateFilmstrip(media) } }
         // Proxies are chunked and demand-driven — see ChunkManager. Whole-file
         // proxy.mov caches from earlier versions keep being used when present.
     }
 
-    // MARK: - Waveforms (audio clips)
+    /// Called from the draw path for media currently ON SCREEN: build its coarse
+    /// strip / peaks NOW, on the high-priority demand queue, ahead of the
+    /// background fill. This is what makes the view you zoom to fill in first
+    /// instead of waiting behind distant media. Cheap and idempotent — enqueues
+    /// each media once (the generate bodies dedup against the background job and
+    /// against anything already on disk). Thread-safe: draw runs on parallel lanes.
+    func prioritizeMedia(_ media: MediaItem) {
+        guard ffmpeg != nil else { return }
+        let key = media.cacheKey
+        imgStateLock.lock()
+        let wantStrip = media.width > 0 && stripInfoCache[key] == nil && !stripDemanded.contains(key)
+        if wantStrip { stripDemanded.insert(key) }
+        let wantPeaks = media.isAudio && peakCache[key] == nil && !peaksDemanded.contains(key)
+        if wantPeaks { peaksDemanded.insert(key) }
+        imgStateLock.unlock()
+        if wantStrip { demandQueue.addOperation { self.generateFilmstrip(media) } }
+        if wantPeaks { demandQueue.addOperation { self.generatePeaks(media) } }
+    }
+
+    // MARK: - Waveform peaks (audio clips) — Reaper-style min/max pyramid
 
-    private func waveformURL(_ key: String) -> URL {
-        keyDir(key).appendingPathComponent("waveform.png")
+    private func peaksURL(_ key: String) -> URL {
+        keyDir(key).appendingPathComponent("peaks.bin", isDirectory: false)
     }
 
-    private func generateWaveform(_ media: MediaItem) {
+    // On-disk format (little-endian): "SQPK" magic, u32 version, u32 samplerate,
+    // u32 samplesPerBaseBucket, u32 levelCount, then per level a u32 bucketCount,
+    // then per level bucketCount×2 Int8 (min,max). Amplitudes are the source
+    // Int16 divided by 256 → Int8, plenty for a waveform.
+    private static let peakMagic: [UInt8] = [0x53, 0x51, 0x50, 0x4B]   // "SQPK"
+    private static let peakSampleRate = 22_050
+    private static let peakBaseSamples = 256   // samples per level-0 bucket
+    static var peakBaseBucketDur: Double { Double(peakBaseSamples) / Double(peakSampleRate) }
+
+    /// Decode the file's audio to mono s16le and reduce it to a base min/max
+    /// bucket stream ON THE FLY, then build the ×2 pyramid and write it. The PCM
+    /// is consumed in chunks and never fully buffered — a 4-hour source is
+    /// gigabytes of samples, so this must stream.
+    private var stripBuilding = Set<String>()   // claimed at generate time
+    private var peaksBuilding = Set<String>()
+
+    private func generatePeaks(_ media: MediaItem) {
         guard let ffmpeg else { return }
+        let key = media.cacheKey
+        // Claim: the background and demand queues may both hold a job for this
+        // media; only the first into the body generates.
+        imgStateLock.lock()
+        let taken = peaksBuilding.contains(key)
+        if !taken { peaksBuilding.insert(key) }
+        imgStateLock.unlock()
+        if taken { return }
+        defer { imgStateLock.lock(); peaksBuilding.remove(key); imgStateLock.unlock() }
+        // Already on disk (the other queue finished first, or a prior session):
+        // nothing to do — the draw path will load it.
+        if FileManager.default.fileExists(atPath: peaksURL(key).path) { return }
         try? FileManager.default.createDirectory(at: keyDir(media.cacheKey),
                                                  withIntermediateDirectories: true)
-        let res = Self.run(ffmpeg, [
-            "-y", "-i", media.path,
-            "-filter_complex",
-            "aformat=channel_layouts=mono,showwavespic=s=2048x200:colors=white",
-            "-frames:v", "1", waveformURL(media.cacheKey).path,
-        ])
-        let bytes = (try? FileManager.default.attributesOfItem(
-            atPath: waveformURL(media.cacheKey).path)[.size] as? NSNumber)?.int64Value ?? 0
+        let p = Process()
+        p.executableURL = URL(fileURLWithPath: ffmpeg)
+        p.arguments = ["-v", "quiet", "-i", media.path,
+                       "-ac", "1", "-ar", "\(Self.peakSampleRate)", "-f", "s16le", "-"]
+        let pipe = Pipe()
+        p.standardOutput = pipe
+        p.standardError = Pipe()
+
+        var mins: [Int8] = [], maxs: [Int8] = []
+        var curMin: Int16 = 0, curMax: Int16 = 0, n = 0
+        func flush() {
+            mins.append(Int8(clamping: Int(curMin) / 256))
+            maxs.append(Int8(clamping: Int(curMax) / 256))
+            curMin = 0; curMax = 0; n = 0
+        }
+        func consume(_ data: Data) {
+            data.withUnsafeBytes { (raw: UnsafeRawBufferPointer) in
+                let s = raw.bindMemory(to: Int16.self)
+                for i in 0..<s.count {
+                    let v = Int16(littleEndian: s[i])
+                    if n == 0 { curMin = v; curMax = v }
+                    else { if v < curMin { curMin = v }; if v > curMax { curMax = v } }
+                    n += 1
+                    if n >= Self.peakBaseSamples { flush() }
+                }
+            }
+        }
+
+        do { try p.run() } catch { return }
+        Self.childLock.lock(); Self.liveChildren[p.processIdentifier] = p; Self.childLock.unlock()
+        let fh = pipe.fileHandleForReading
+        var leftover = Data()
+        while true {
+            let chunk = fh.availableData
+            if chunk.isEmpty { break }
+            let d = leftover.isEmpty ? chunk : leftover + chunk
+            let even = d.count - (d.count & 1)
+            if even < d.count { leftover = d.suffix(from: even) } else { leftover.removeAll() }
+            if even > 0 { consume(d.prefix(even)) }
+        }
+        p.waitUntilExit()
+        Self.childLock.lock(); Self.liveChildren.removeValue(forKey: p.processIdentifier); Self.childLock.unlock()
+        if n > 0 { flush() }
+        guard p.terminationStatus == 0, !mins.isEmpty else { return }
+
+        // Interleave base level, then halve until small.
+        var levels: [[Int8]] = []
+        var base: [Int8] = []; base.reserveCapacity(mins.count * 2)
+        for i in mins.indices { base.append(mins[i]); base.append(maxs[i]) }
+        levels.append(base)
+        while levels[levels.count - 1].count / 2 > 256 {
+            let prev = levels[levels.count - 1]
+            let pc = prev.count / 2
+            var next: [Int8] = []; next.reserveCapacity(pc + 2)
+            var i = 0
+            while i < pc {
+                var mn = prev[2 * i], mx = prev[2 * i + 1]
+                if i + 1 < pc { mn = min(mn, prev[2 * i + 2]); mx = max(mx, prev[2 * i + 3]) }
+                next.append(mn); next.append(mx)
+                i += 2
+            }
+            levels.append(next)
+        }
+
+        var out = Data()
+        func u32(_ v: Int) { var x = UInt32(v).littleEndian; withUnsafeBytes(of: &x) { out.append(contentsOf: $0) } }
+        out.append(contentsOf: Self.peakMagic)
+        u32(1); u32(Self.peakSampleRate); u32(Self.peakBaseSamples); u32(levels.count)
+        for l in levels { u32(l.count / 2) }
+        for l in levels { l.withUnsafeBytes { out.append(contentsOf: $0) } }
+        try? out.write(to: peaksURL(media.cacheKey))
+        let bytes = Int64(out.count)
         DispatchQueue.main.async {
             self.touchLRU(media.cacheKey)
-            if res.exitCode == 0 {
-                self.noteBytesAdded(bytes)
+            self.noteBytesAdded(bytes)
+            self.imgStateLock.lock()
+            self.peaksMissing.remove(media.cacheKey)
+            self.imgStateLock.unlock()
+            // `scene: true` — waveform pixels changed, so the tile cache flushes.
+            NotificationCenter.default.post(name: .mediaStatusChanged, object: nil,
+                                            userInfo: ["scene": true])
+        }
+    }
+
+    /// Headless check for `--peaktest <audiofile>`: generate the peak pyramid,
+    /// reload it, and report. Generation is synchronous (the final notify hops
+    /// to a main runloop that a CLI never spins, but the file is written first).
+    func runPeakTest(path: String) {
+        var item = MediaItem(path: path)
+        item.isAudio = true
+        item.cacheKey = Self.cacheKey(for: item.url)
+        let t0 = Date()
+        generatePeaks(item)
+        let dt = Date().timeIntervalSince(t0)
+        let url = peaksURL(item.cacheKey)
+        let size = (try? FileManager.default.attributesOfItem(atPath: url.path)[.size]
+                        as? NSNumber)?.int64Value ?? 0
+        guard let pk = Self.loadPeaks(url) else { print("peaktest: FAIL to load"); return }
+        let l0 = pk.levels[0]
+        var mx: Int8 = 0
+        for i in stride(from: 1, to: l0.count, by: 2) where l0[i] > mx { mx = l0[i] }
+        print(String(format: "peaktest OK  gen=%.1fs file=%.2fMB levels=%d base=%d buckets baseDur=%.4fs peakMax=%d",
+                     dt, Double(size) / 1e6, pk.levels.count, l0.count / 2,
+                     pk.baseBucketDur, Int(mx)))
+        for pps in [2.0, 50.0, 500.0, 4000.0] {
+            let lv = pk.level(forSrcSecPerPixel: 1.0 / pps)
+            print(String(format: "  pps=%.0f → level %d (bucketDur %.4fs)", pps, lv, pk.bucketDur(lv)))
+        }
+    }
+
+    /// Headless check for `--thumbtest <videofile>`: build the coarse keyframe
+    /// strip and one fine window, and report timings/counts.
+    func runThumbTest(path: String) {
+        guard let ffprobe else { print("thumbtest: no ffprobe"); return }
+        var item = MediaItem(path: path)
+        item.cacheKey = Self.cacheKey(for: item.url)
+        let probe = Self.run(ffprobe, ["-v", "quiet", "-select_streams", "v:0",
+            "-show_entries", "stream=width,height:format=duration",
+            "-of", "default=nk=1:nw=1", path]).stdout.split(separator: "\n").map(String.init)
+        item.width = Int(probe.first ?? "") ?? 1920
+        item.height = probe.count > 1 ? Int(probe[1]) ?? 1080 : 1080
+        item.duration = Double(probe.last ?? "") ?? 0
+        let t0 = Date()
+        generateFilmstrip(item)
+        let coarseT = Date().timeIntervalSince(t0)
+        let times = filmstripTimes(item.cacheKey) ?? []
+        print(String(format: "thumbtest COARSE  gen=%.1fs frames=%d span=%.0f→%.0fs (%.0fx%.0f, dur %.0fs)",
+                     coarseT, times.count, times.first ?? -1, times.last ?? -1,
+                     Double(item.width), Double(item.height), item.duration))
+        // Fine window near the middle.
+        let mid = item.duration / 2
+        let b0 = Self.fineBucket(mid), b1 = Self.fineBucket(mid + 30)
+        let t1 = Date()
+        generateFineWindow(item, b0: b0, b1: b1)
+        let fineT = Date().timeIntervalSince(t1)
+        let fineCount = (try? FileManager.default.contentsOfDirectory(atPath: fineDir(item.cacheKey).path))?
+            .filter { $0.hasSuffix(".jpg") }.count ?? 0
+        let hit = fineThumbImage(for: item, at: mid + 10) != nil
+            || FileManager.default.fileExists(atPath: fineDir(item.cacheKey)
+                .appendingPathComponent(String(format: "%06d.jpg", Self.fineBucket(mid + 10)), isDirectory: false).path)
+        print(String(format: "thumbtest FINE    gen=%.1fs buckets=%d [%d…%d] sampleHit=%@",
+                     fineT, fineCount, b0, b1, hit ? "yes" : "no"))
+    }
+
+    private var peakCache: [String: PeakData] = [:]   // lock-guarded
+    private var peaksMissing = Set<String>()
+    private var peaksLoading = Set<String>()
+
+    private static func loadPeaks(_ url: URL) -> PeakData? {
+        guard let data = try? Data(contentsOf: url), data.count > 24 else { return nil }
+        return data.withUnsafeBytes { (raw: UnsafeRawBufferPointer) -> PeakData? in
+            var off = 0
+            func u32() -> Int { let v = raw.loadUnaligned(fromByteOffset: off, as: UInt32.self); off += 4; return Int(UInt32(littleEndian: v)) }
+            guard Array(raw[0..<4]) == peakMagic else { return nil }
+            off = 4
+            guard u32() == 1 else { return nil }
+            _ = u32()                       // sampleRate
+            let baseSamples = u32()
+            let levelCount = u32()
+            guard levelCount > 0, levelCount < 64 else { return nil }
+            var counts: [Int] = []
+            for _ in 0..<levelCount { counts.append(u32()) }
+            var levels: [[Int8]] = []
+            for c in counts {
+                let bytes = c * 2
+                guard off + bytes <= raw.count else { return nil }
+                var arr = [Int8](repeating: 0, count: bytes)
+                for i in 0..<bytes { arr[i] = Int8(bitPattern: raw[off + i]) }
+                off += bytes
+                levels.append(arr)
+            }
+            return PeakData(baseBucketDur: Double(baseSamples) / Double(peakSampleRate), levels: levels)
+        }
+    }
+
+    /// Cached peak pyramid for an audio media, loaded async on first ask.
+    /// Negatively cached so a dense timeline doesn't re-dispatch a load per
+    /// clip per frame. Lock-guarded: lanes rasterize on parallel threads.
+    func peaks(for media: MediaItem) -> PeakData? {
+        let key = media.cacheKey
+        imgStateLock.lock()
+        if let p = peakCache[key] { imgStateLock.unlock(); return p }
+        let skip = peaksMissing.contains(key) || peaksLoading.contains(key)
+        if !skip { peaksLoading.insert(key) }
+        imgStateLock.unlock()
+        guard !skip else { return nil }
+        let url = peaksURL(key)
+        DispatchQueue.global(qos: .utility).async {
+            let parsed = Self.loadPeaks(url)
+            DispatchQueue.main.async {
                 self.imgStateLock.lock()
-                self.waveformMissing.remove(media.cacheKey)
+                self.peaksLoading.remove(key)
+                if let parsed { self.peakCache[key] = parsed } else { self.peaksMissing.insert(key) }
                 self.imgStateLock.unlock()
-                // `scene: true` — a waveform image changes timeline pixels
-                // (the tile cache flushes on it; plain chunk churn must not).
-                NotificationCenter.default.post(name: .mediaStatusChanged, object: nil,
-                                                userInfo: ["scene": true])
+                if parsed != nil { self.notifyThumbsCoalesced() }   // scene re-render
             }
         }
+        return nil
     }
 
-    private let waveformCache = NSCache<NSString, CGImage>()
-
     /// Decode an image file straight into the display's raster format (BGRA
     /// premultiplied, screen colorspace). A plain NSImage/CGImageSource image
     /// keeps the file's own format (RGB JPEG, generic colorspace), and Quartz
@@ -294,63 +736,68 @@ final class MediaPipeline {
         return ctx.makeImage() ?? raw
     }
 
-    /// Same negative/in-flight bookkeeping as thumbnails: a missing waveform
-    /// must not re-dispatch a load per audio clip per frame.
-    private var waveformMissing = Set<String>()
-    private var waveformLoading = Set<String>()
-
-    func waveformImage(for media: MediaItem) -> CGImage? {
-        let key = media.cacheKey
-        if let img = waveformCache.object(forKey: key as NSString) { return img }
-        imgStateLock.lock()
-        let skip = waveformMissing.contains(key) || waveformLoading.contains(key)
-        if !skip { waveformLoading.insert(key) }
-        imgStateLock.unlock()
-        guard !skip else { return nil }
-        let url = waveformURL(key)
-        DispatchQueue.global(qos: .utility).async {
-            let img = Self.displayImage(contentsOf: url)
-            DispatchQueue.main.async {
-                self.imgStateLock.lock()
-                self.waveformLoading.remove(key)
-                if img == nil { self.waveformMissing.insert(key) }
-                self.imgStateLock.unlock()
-                if let img {
-                    self.waveformCache.setObject(img, forKey: key as NSString)
-                    self.notifyThumbsCoalesced()
-                }
-            }
-        }
-        return nil
-    }
-
     // MARK: - Jobs
 
     private func generateFilmstrip(_ media: MediaItem) {
         guard let ffmpeg else { return }
+        let key = media.cacheKey
+        // Claim: background and demand queues may both hold a job — first wins.
+        imgStateLock.lock()
+        let taken = stripBuilding.contains(key)
+        if !taken { stripBuilding.insert(key) }
+        imgStateLock.unlock()
+        if taken { return }
+        defer { imgStateLock.lock(); stripBuilding.remove(key); imgStateLock.unlock() }
+        // Already built (other queue finished first, or a prior session): adopt
+        // the on-disk index so the view can draw it, and skip regeneration.
+        if FileManager.default.fileExists(atPath: stripInfoURL(key).path) {
+            if let t = filmstripTimes(key) {
+                DispatchQueue.main.async {
+                    NotificationCenter.default.post(name: .mediaStatusChanged, object: nil,
+                                                    userInfo: ["scene": true])
+                    _ = t
+                }
+            }
+            return
+        }
         let dir = stripDir(media.cacheKey)
         try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
-        // Target ~600 thumbs max so hour-long recordings stay cheap.
-        let interval = max(0.5, media.duration / 600)
-        let res = Self.run(ffmpeg, ["-y", "-hwaccel", "videotoolbox", "-i", media.path,
-                                    "-vf", "fps=1/\(interval),scale=240:-2",
-                                    "-q:v", "7", dir.appendingPathComponent("%06d.jpg").path])
+        // Coarse tier: keyframe-only decode across the WHOLE file. Skipping
+        // inter-frames turns a 4-hour 4K source from ~8 min (the old fps filter
+        // decoded every frame and never finished on long media) into a few
+        // seconds, so every clip reliably gets a strip. Keyframes are
+        // irregularly spaced, so their source times are captured from a
+        // parallel keyframe probe and stored as an index the draw path searches.
+        _ = Self.run(ffmpeg, ["-y", "-skip_frame", "nokey", "-hwaccel", "videotoolbox",
+                              "-an", "-sn", "-vsync", "0", "-i", media.path,
+                              "-vf", "scale=240:-2", "-q:v", "6",
+                              dir.appendingPathComponent("%06d.jpg").path])
         let count = (try? FileManager.default.contentsOfDirectory(atPath: dir.path))?
-            .filter { $0.hasSuffix(".jpg") }.count ?? 0
-        if res.exitCode == 0, count > 0 {
-            let info: [String: Any] = ["interval": interval, "count": count]
-            if let d = try? JSONSerialization.data(withJSONObject: info) {
-                try? d.write(to: stripInfoURL(media.cacheKey))
-            }
+            .filter { $0.hasSuffix(".jpg") && !$0.hasPrefix("f") }.count ?? 0
+        var times: [Double] = []
+        if count > 0, let ffprobe {
+            let probe = Self.run(ffprobe, ["-v", "quiet", "-select_streams", "v",
+                "-skip_frame", "nokey", "-show_entries", "frame=pts_time",
+                "-of", "csv=p=0", media.path])
+            times = probe.stdout.split(separator: "\n").compactMap { Double($0) }.sorted()
+        }
+        // If the probe and extraction disagree (rare muxer quirks), fall back to
+        // an even spread so every JPEG still maps to a plausible time.
+        if times.count != count, count > 0 {
+            times = (0..<count).map { media.duration * (Double($0) + 0.5) / Double(count) }
+        }
+        if count > 0, let d = try? JSONSerialization.data(withJSONObject: ["times": times]) {
+            try? d.write(to: stripInfoURL(media.cacheKey))
         }
         let bytes = Self.directorySize(dir)
         DispatchQueue.main.async {
             var s = self.status(for: media)
-            s.filmstripReady = res.exitCode == 0 && count > 0
+            s.filmstripReady = count > 0
             self.statuses[media.id] = s
             self.touchLRU(media.cacheKey)
             self.noteBytesAdded(bytes)
             self.imgStateLock.lock()
+            self.stripInfoCache[media.cacheKey] = times.isEmpty ? nil : times
             self.thumbMissing.removeAll()   // a fresh strip supersedes misses
             self.imgStateLock.unlock()
             NotificationCenter.default.post(name: .mediaStatusChanged, object: nil,
@@ -360,44 +807,59 @@ final class MediaPipeline {
 
     // MARK: - Filmstrip access
 
-    func filmstripInfo(_ key: String) -> (interval: Double, count: Int)? {
+    /// Sorted source-second timestamps of the coarse keyframe thumbnails
+    /// (`%06d.jpg`, 1-based). Reads the new `times` index and the legacy
+    /// interval/count format so old caches still resolve.
+    func filmstripTimes(_ key: String) -> [Double]? {
         imgStateLock.lock()
         let cached = stripInfoCache[key]
         imgStateLock.unlock()
         if let cached { return cached }
         guard let data = try? Data(contentsOf: stripInfoURL(key)),
-              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-              let interval = json["interval"] as? Double,
-              let count = json["count"] as? Int else { return nil }
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else { return nil }
+        var times: [Double] = []
+        if let t = json["times"] as? [Double] {
+            times = t
+        } else if let interval = json["interval"] as? Double, let count = json["count"] as? Int {
+            times = (0..<count).map { interval * (Double($0) + 0.5) }   // legacy strip
+        }
+        guard !times.isEmpty else { return nil }
         imgStateLock.lock()
-        stripInfoCache[key] = (interval, count)
+        stripInfoCache[key] = times
         imgStateLock.unlock()
-        return (interval, count)
+        return times
     }
 
-    /// Cached thumbnail nearest to `seconds`; loads async and posts a single
-    /// coalesced .mediaStatusChanged when thumbs land (a post per thumb
-    /// cascades into an app-wide refresh storm while a filmstrip streams in).
-    /// Thumbs that failed to load (file absent/evicted) or are mid-load.
-    /// Without these a dense timeline re-dispatches a load per missing thumb
-    /// per FRAME — hundreds of no-op queue hops every draw. Misses are
-    /// forgotten whenever fresh thumbs land (strips may have regenerated).
-    /// Lock-guarded: the timeline rasterizes lanes on parallel threads.
+    /// Index in `sorted` of the value nearest `x` (binary search).
+    private static func nearestIndex(_ sorted: [Double], _ x: Double) -> Int {
+        if sorted.isEmpty { return 0 }
+        var lo = 0, hi = sorted.count - 1
+        while lo < hi {
+            let mid = (lo + hi) / 2
+            if sorted[mid] < x { lo = mid + 1 } else { hi = mid }
+        }
+        if lo > 0, abs(sorted[lo - 1] - x) <= abs(sorted[lo] - x) { return lo - 1 }
+        return lo
+    }
+
+    /// Thumbs that failed to load (file absent/evicted) or are mid-load. Without
+    /// these a dense timeline re-dispatches a load per missing thumb per FRAME —
+    /// hundreds of no-op queue hops every draw. Misses are forgotten whenever
+    /// fresh thumbs land. Lock-guarded: lanes rasterize on parallel threads.
     private var thumbMissing = Set<String>()
     private var thumbLoading = Set<String>()
     private let imgStateLock = NSLock()
 
-    func filmstripImage(for media: MediaItem, at seconds: Double) -> CGImage? {
-        guard let info = filmstripInfo(media.cacheKey) else { return nil }
-        let index = min(info.count, max(1, Int(seconds / info.interval) + 1))
-        let cacheId = "\(media.cacheKey)/\(index)"
+    /// Load-and-cache a thumbnail file, with the shared negative/in-flight
+    /// bookkeeping. `cacheId` keys the RAM cache and miss sets; `url` is the JPEG.
+    private func thumb(_ cacheId: String, _ url: URL) -> CGImage? {
         if let img = thumbCache.object(forKey: cacheId as NSString) { return img }
         imgStateLock.lock()
         let skip = thumbMissing.contains(cacheId) || thumbLoading.contains(cacheId)
         if !skip { thumbLoading.insert(cacheId) }
         imgStateLock.unlock()
         guard !skip else { return nil }
-        let url = stripDir(media.cacheKey).appendingPathComponent(String(format: "%06d.jpg", index))
         DispatchQueue.global(qos: .utility).async {
             let img = Self.displayImage(contentsOf: url)
             DispatchQueue.main.async {
@@ -414,6 +876,175 @@ final class MediaPipeline {
         return nil
     }
 
+    /// Coarse keyframe thumbnail nearest to `seconds`. Always available once the
+    /// (cheap) strip is built, so every clip shows something at any zoom.
+    /// `maxDistance` guards stand-in use: the strip is keyframe-anchored, so on
+    /// sparse-keyframe media the nearest thumb can be far from `seconds` — an
+    /// unrelated picture. Pass a bound to get nil instead when it's too far
+    /// (timeline strips pass nil: there a positional approximation is fine).
+    func filmstripImage(for media: MediaItem, at seconds: Double,
+                        maxDistance: Double? = nil) -> CGImage? {
+        guard let times = filmstripTimes(media.cacheKey), !times.isEmpty else { return nil }
+        let i = Self.nearestIndex(times, seconds)
+        if let maxDistance, abs(times[i] - seconds) > maxDistance { return nil }
+        let index = i + 1   // files are 1-based
+        return thumb("\(media.cacheKey)/c\(index)",
+                     stripDir(media.cacheKey).appendingPathComponent(String(format: "%06d.jpg", index), isDirectory: false))
+    }
+
+    // MARK: - Fine on-demand thumbnails (viewport-driven detail)
+
+    /// Seconds per fine thumbnail. Fine thumbs are stored in `strip/fine/` named
+    /// by absolute bucket = round(sourceSec / interval), so windows just fill in
+    /// buckets — no per-window directories.
+    static let fineThumbInterval = 0.5
+    static func fineBucket(_ seconds: Double) -> Int { max(0, Int((seconds / fineThumbInterval).rounded())) }
+    private func fineDir(_ key: String) -> URL { stripDir(key).appendingPathComponent("fine", isDirectory: true) }
+
+    /// A fine thumbnail for `seconds` if that bucket has been generated, else nil
+    /// (caller falls back to the coarse strip). Never triggers generation — that
+    /// is `requestFineWindow`, driven by the visible range.
+    func fineThumbImage(for media: MediaItem, at seconds: Double) -> CGImage? {
+        let bucket = Self.fineBucket(seconds)
+        return thumb("\(media.cacheKey)/f\(bucket)",
+                     fineDir(media.cacheKey).appendingPathComponent(String(format: "%06d.jpg", bucket), isDirectory: false))
+    }
+
+    // Fine bucket ranges already built or building, per media — so panning at a
+    // tight zoom coalesces into a few window jobs instead of one per frame.
+    // Lock-guarded (imgStateLock): requested from the parallel draw threads.
+    private var fineDone: [String: [ClosedRange<Int>]] = [:]
+    private var fineBuilding = Set<String>()
+
+    /// Ensure fine thumbnails exist for the visible source span `[s0, s1]` of a
+    /// video media. Coalesced: only a range not already built/in-flight enqueues
+    /// a job, and only one job per media runs at a time (the newest visible span
+    /// wins). Call from the draw path when zoomed in enough to benefit.
+    func requestFineWindow(for media: MediaItem, from s0: Double, to s1: Double) {
+        guard ffmpeg != nil, media.width > 0, media.duration > 0 else { return }
+        let key = media.cacheKey
+        // Pad a little so small pans stay covered, clamp to the media.
+        let lo = max(0, s0 - 2), hi = min(media.duration, s1 + 2)
+        let b0 = Self.fineBucket(lo), b1 = Self.fineBucket(hi)
+        guard b1 >= b0 else { return }
+        imgStateLock.lock()
+        let covered = fineDone[key]?.contains { $0.lowerBound <= b0 && $0.upperBound >= b1 } ?? false
+        let busy = fineBuilding.contains(key)
+        if !covered && !busy { fineBuilding.insert(key) }
+        imgStateLock.unlock()
+        guard !covered, !busy else { return }
+        // Cap the window so a huge visible span doesn't spawn a giant job.
+        let capped = min(b1, b0 + 600)
+        demandQueue.addOperation { self.generateFineWindow(media, b0: b0, b1: capped) }
+    }
+
+    private func generateFineWindow(_ media: MediaItem, b0: Int, b1: Int) {
+        defer {
+            self.imgStateLock.lock()
+            self.fineBuilding.remove(media.cacheKey)
+            self.fineDone[media.cacheKey, default: []].append(b0...b1)
+            self.imgStateLock.unlock()
+        }
+        guard let ffmpeg else { return }
+        let dir = fineDir(media.cacheKey)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let interval = Self.fineThumbInterval
+        let start = Double(b0) * interval
+        let dur = Double(b1 - b0 + 1) * interval
+        // -ss on the input seeks fast (keyframe index); the fps filter then emits
+        // one frame per `interval` from there, and -start_number names each by its
+        // absolute bucket so it lands at strip/fine/<bucket>.jpg.
+        _ = Self.run(ffmpeg, ["-y", "-hwaccel", "videotoolbox", "-ss", "\(start)",
+                              "-t", "\(dur)", "-i", media.path, "-an", "-sn",
+                              "-vf", "fps=1/\(interval),scale=240:-2", "-q:v", "6",
+                              "-start_number", "\(b0)",
+                              dir.appendingPathComponent("%06d.jpg").path])
+        DispatchQueue.main.async {
+            self.imgStateLock.lock()
+            let k = media.cacheKey
+            self.thumbMissing = self.thumbMissing.filter { !$0.hasPrefix(k) }
+            self.imgStateLock.unlock()
+            NotificationCenter.default.post(name: .mediaStatusChanged, object: nil,
+                                            userInfo: ["scene": true])
+        }
+    }
+
+    // MARK: - Edit-fine thumbnails (frame-accurate, during resize/slip)
+
+    /// While a clip is being resized/slipped, its visible source range is filled
+    /// at ONE thumbnail per SOURCE FRAME so the frames literally move under the
+    /// drag instead of snapping to the 0.5 s fine grid. Interval = the media's
+    /// own frame period, clamped so a 60 fps source doesn't over-generate. Stored
+    /// in `strip/ef/`, bucketed by `round(sec / interval)`.
+    func editFineInterval(for media: MediaItem) -> Double {
+        max(0.04, 1.0 / max(1, media.fps))
+    }
+    private func editFineDir(_ key: String) -> URL {
+        stripDir(key).appendingPathComponent("ef", isDirectory: true)
+    }
+    private func editFineBucket(_ seconds: Double, _ interval: Double) -> Int {
+        max(0, Int((seconds / interval).rounded()))
+    }
+    func editFineImage(for media: MediaItem, at seconds: Double) -> CGImage? {
+        let bucket = editFineBucket(seconds, editFineInterval(for: media))
+        return thumb("\(media.cacheKey)/e\(bucket)",
+                     editFineDir(media.cacheKey).appendingPathComponent(String(format: "%06d.jpg", bucket), isDirectory: false))
+    }
+
+    private var efDone: [String: [ClosedRange<Int>]] = [:]
+    private var efBuilding = Set<String>()
+
+    /// Ensure per-frame thumbnails exist for `[s0, s1]` of the media being
+    /// edited. Coalesced like the fine window; the newest visible span wins.
+    func requestEditFineWindow(for media: MediaItem, from s0: Double, to s1: Double) {
+        if ProcessInfo.processInfo.environment["SEQ_DEBUG"] != nil {
+            FileHandle.standardError.write(Data("editfine req \(media.displayName) \(s0)-\(s1) w=\(media.width)\n".utf8))
+        }
+        guard ffmpeg != nil, media.width > 0, media.duration > 0 else { return }
+        let key = media.cacheKey
+        let interval = editFineInterval(for: media)
+        let b0 = editFineBucket(max(0, s0), interval)
+        let b1 = editFineBucket(min(media.duration, s1), interval)
+        guard b1 >= b0 else { return }
+        imgStateLock.lock()
+        let covered = efDone[key]?.contains { $0.lowerBound <= b0 && $0.upperBound >= b1 } ?? false
+        let busy = efBuilding.contains(key)
+        if !covered && !busy { efBuilding.insert(key) }
+        imgStateLock.unlock()
+        guard !covered, !busy else { return }
+        let capped = min(b1, b0 + 400)
+        demandQueue.addOperation {
+            self.generateEditFineWindow(media, b0: b0, b1: capped, interval: interval)
+        }
+    }
+
+    private func generateEditFineWindow(_ media: MediaItem, b0: Int, b1: Int, interval: Double) {
+        defer {
+            self.imgStateLock.lock()
+            self.efBuilding.remove(media.cacheKey)
+            self.efDone[media.cacheKey, default: []].append(b0...b1)
+            self.imgStateLock.unlock()
+        }
+        guard let ffmpeg else { return }
+        let dir = editFineDir(media.cacheKey)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let start = Double(b0) * interval
+        let dur = Double(b1 - b0 + 1) * interval
+        _ = Self.run(ffmpeg, ["-y", "-hwaccel", "videotoolbox", "-ss", "\(start)",
+                              "-t", "\(dur)", "-i", media.path, "-an", "-sn",
+                              "-vf", "fps=1/\(interval),scale=240:-2", "-q:v", "6",
+                              "-start_number", "\(b0)",
+                              dir.appendingPathComponent("%06d.jpg").path])
+        DispatchQueue.main.async {
+            self.imgStateLock.lock()
+            let k = media.cacheKey
+            self.thumbMissing = self.thumbMissing.filter { !$0.hasPrefix(k) }
+            self.imgStateLock.unlock()
+            NotificationCenter.default.post(name: .mediaStatusChanged, object: nil,
+                                            userInfo: ["scene": true])
+        }
+    }
+
     private var thumbNotifyPending = false
     private func notifyThumbsCoalesced() {
         guard !thumbNotifyPending else { return }
@@ -434,7 +1065,7 @@ final class MediaPipeline {
         let now = Date()
         if let last = lruTouched[key], now.timeIntervalSince(last) < 60 { return }
         lruTouched[key] = now
-        let url = keyDir(key).appendingPathComponent("lastUsed")
+        let url = keyDir(key).appendingPathComponent("lastUsed", isDirectory: false)
         try? "\(now.timeIntervalSince1970)".write(to: url, atomically: true, encoding: .utf8)
     }
 
@@ -473,7 +1104,11 @@ final class MediaPipeline {
         let root = cacheRoot
         DispatchQueue.global(qos: .utility).async {
             Self.purgeSessionTransients(root: root)
+            // The audio subroot has its own budget — its bytes must not count
+            // against (or ever be evicted by) the video chunk cap.
             let total = Self.directorySize(root)
+                - Self.directorySize(root.appendingPathComponent(Self.audioDirName,
+                                                                 isDirectory: true))
             DispatchQueue.main.async {
                 NSLog("[cache] reconcile: %.2f GB on disk (cap %.0f GB)",
                       Double(total) / 1e9, Double(self.maxCacheBytes) / 1e9)
@@ -554,11 +1189,11 @@ final class MediaPipeline {
             // 1. Closed projects' whole cache dirs, least recently used first.
             if let keys = try? fm.contentsOfDirectory(atPath: root.path) {
                 var entries: [(key: String, lastUsed: Double)] = []
-                for key in keys where !inUse.contains(key) {
+                for key in keys where !inUse.contains(key) && key != Self.audioDirName {
                     let dir = root.appendingPathComponent(key, isDirectory: true)
                     var isDir: ObjCBool = false
                     guard fm.fileExists(atPath: dir.path, isDirectory: &isDir), isDir.boolValue else { continue }
-                    let lastUsed = Double((try? String(contentsOf: dir.appendingPathComponent("lastUsed"), encoding: .utf8)) ?? "") ?? 0
+                    let lastUsed = Double((try? String(contentsOf: dir.appendingPathComponent("lastUsed", isDirectory: false), encoding: .utf8)) ?? "") ?? 0
                     entries.append((key, lastUsed))
                 }
                 for e in entries.sorted(by: { $0.lastUsed < $1.lastUsed }) {
@@ -589,6 +1224,12 @@ final class MediaPipeline {
                 self.imgStateLock.lock()
                 for k in evictedDirs {
                     self.stripInfoCache[k] = nil
+                    self.peakCache[k] = nil
+                    self.peaksMissing.remove(k)
+                    self.fineDone[k] = nil          // its fine thumbs are gone too
+                    self.efDone[k] = nil
+                    self.stripDemanded.remove(k)    // let a re-view rebuild them
+                    self.peaksDemanded.remove(k)
                 }
                 self.imgStateLock.unlock()
                 for k in evictedDirs {
@@ -627,7 +1268,7 @@ final class MediaPipeline {
             let name = f.lastPathComponent
             let isRescue = name.hasPrefix("r") && name.hasSuffix(".mov") && name.count == 11
                 && f.deletingLastPathComponent().lastPathComponent == "chunks"
-            let isTemp = name.hasSuffix(".partial.mov")
+            let isTemp = name.hasSuffix(".partial.mov") || name.hasSuffix(".building.mov")
             guard isRescue || isTemp else { continue }
             let m = (try? f.resourceValues(forKeys: [.contentModificationDateKey])
                         .contentModificationDate) ?? .distantPast
diff --git a/sequencer/Sources/Sequencer/Model.swift b/sequencer/Sources/Sequencer/Model.swift
index 9594318e3641ac1096a492efe17812512929d01b..b97b2eaa2cce9e15cd10ff072a7c146d268b624f 100644
--- a/sequencer/Sources/Sequencer/Model.swift
+++ b/sequencer/Sources/Sequencer/Model.swift
@@ -17,13 +17,15 @@ enum TrackRef: Hashable, Codable {
     case video(Int)
     case storyboard
     case fusion
+    case reaper(Int)   // REAPER sidecar lanes, mirroring the .rpp's tracks
 
-    /// Compact, human-readable wire form: "v0", "v1", "storyboard", "fusion".
+    /// Compact, human-readable wire form: "v0", "v1", "storyboard", "fusion", "r0".
     var wire: String {
         switch self {
-        case .video(let i): return "v\(i)"
-        case .storyboard:   return "storyboard"
-        case .fusion:       return "fusion"
+        case .video(let i):  return "v\(i)"
+        case .storyboard:    return "storyboard"
+        case .fusion:        return "fusion"
+        case .reaper(let i): return "r\(i)"
         }
     }
     init?(wire: String) {
@@ -31,11 +33,16 @@ enum TrackRef: Hashable, Codable {
         case "storyboard": self = .storyboard
         case "fusion":     self = .fusion
         default:
+            if wire.hasPrefix("r"), let i = Int(wire.dropFirst()), i >= 0 {
+                self = .reaper(i); return
+            }
             guard wire.hasPrefix("v"), let i = Int(wire.dropFirst()), i >= 0 else { return nil }
             self = .video(i)
         }
     }
     var videoIndex: Int? { if case .video(let i) = self { return i }; return nil }
+    var reaperIndex: Int? { if case .reaper(let i) = self { return i }; return nil }
+    var isReaper: Bool { reaperIndex != nil }
 
     init(from decoder: Decoder) throws {
         let s = try decoder.singleValueContainer().decode(String.self)
@@ -74,6 +81,27 @@ enum TrackKind: String, Codable {
     case storyboard
 }
 
+/// One lane of the REAPER sidecar. Mirrors a `<TRACK>` chunk in the sibling
+/// `.rpp`: `guid` is the chunk's GUID (the stable join key for sync), `name`
+/// its NAME. Like video tracks these are numbered — index in
+/// `ProjectModel.reaperTracks` is the lane number a `.reaper(i)` clip refers to.
+struct ReaperTrack: Codable, Equatable {
+    var name: String = ""
+    var guid: String = ""
+
+    init(name: String = "", guid: String = "") {
+        self.name = name
+        self.guid = guid
+    }
+
+    enum CodingKeys: String, CodingKey { case name, guid }
+    init(from decoder: Decoder) throws {
+        let c = try decoder.container(keyedBy: CodingKeys.self)
+        name = try c.decodeIfPresent(String.self, forKey: .name) ?? ""
+        guid = try c.decodeIfPresent(String.self, forKey: .guid) ?? ""
+    }
+}
+
 struct ProjectModel: Codable, Equatable {
     var fps: Double = 30.0
     var media: [MediaItem] = []
@@ -82,6 +110,7 @@ struct ProjectModel: Codable, Equatable {
     var markers: [Marker] = []           // blue timeline markers (labelled or not)
     var compsFolder: String? = nil       // Fusion .comp folder for the comps band
     var preferredTakes: [String] = []    // comp filenames marked as preferred
+    var reaperTracks: [ReaperTrack] = [] // REAPER sidecar lanes (non-empty = linked)
     // Resolution of NEW storyboard panels, stored as concrete pixels rather
     // than a float aspect ratio (which round-trips lossily and compares badly).
     var boardWidth: Int = 1920
@@ -89,6 +118,9 @@ struct ProjectModel: Codable, Equatable {
 
     /// Fixed hue for the (singular) storyboard lane.
     static let storyboardHue = 0.13
+    /// Hue of the REAPER sidecar green (#06FD99) — used wherever lane colors
+    /// derive from `hue(for:)`; the clip body itself hardcodes the exact color.
+    static let reaperHue = 0.4325
 
     /// Aspect ratio derived from the stored resolution, for display/layout.
     var boardAspect: Double { Double(boardWidth) / Double(max(1, boardHeight)) }
@@ -97,7 +129,7 @@ struct ProjectModel: Codable, Equatable {
 
     enum CodingKeys: String, CodingKey {
         case fps, media, tracks, clips, markers, compsFolder, preferredTakes,
-             boardWidth, boardHeight
+             boardWidth, boardHeight, reaperTracks
     }
     // Tolerant decoding so projects saved by older builds keep opening. This
     // decodes the NEW (numbered) schema; legacy UUID-keyed files are migrated
@@ -114,6 +146,7 @@ struct ProjectModel: Codable, Equatable {
         preferredTakes = try c.decodeIfPresent([String].self, forKey: .preferredTakes) ?? []
         if let w = try c.decodeIfPresent(Int.self, forKey: .boardWidth), w > 0 { boardWidth = w }
         if let h = try c.decodeIfPresent(Int.self, forKey: .boardHeight), h > 0 { boardHeight = h }
+        reaperTracks = try c.decodeIfPresent([ReaperTrack].self, forKey: .reaperTracks) ?? []
     }
 
     /// New storyboard boards use the project's storyboard resolution.
@@ -147,6 +180,8 @@ struct ViewState: Codable, Equatable {
     var priorityPane: TrackRef? = nil
     var fusionHidden = false
     var fusionFocus = false
+    /// The REAPER sidecar band collapsed to slivers.
+    var reaperCollapsed = false
     /// Where the playhead was parked at save. Reopening resumes here, which
     /// also tells the proxy cache which neighbourhood to keep warm/protected
     /// for this project while its window is in the background.
@@ -157,7 +192,7 @@ struct ViewState: Codable, Equatable {
     enum CodingKeys: String, CodingKey {
         case hiddenTracks, focusedTracks, trackHeights, laneScale, snapping,
              showFilmstrips, subtitles, previewsOnLeft, priorityPane,
-             fusionHidden, fusionFocus, playhead
+             fusionHidden, fusionFocus, reaperCollapsed, playhead
     }
     init(from decoder: Decoder) throws {
         let c = try decoder.container(keyedBy: CodingKeys.self)
@@ -172,6 +207,7 @@ struct ViewState: Codable, Equatable {
         priorityPane = try c.decodeIfPresent(TrackRef.self, forKey: .priorityPane)
         fusionHidden = try c.decodeIfPresent(Bool.self, forKey: .fusionHidden) ?? false
         fusionFocus = try c.decodeIfPresent(Bool.self, forKey: .fusionFocus) ?? false
+        reaperCollapsed = try c.decodeIfPresent(Bool.self, forKey: .reaperCollapsed) ?? false
         playhead = try c.decodeIfPresent(Double.self, forKey: .playhead) ?? 0
     }
 }
@@ -414,11 +450,16 @@ struct Clip: Codable, Equatable, Identifiable {
     var duration: Double // timeline seconds
     var speed: Double = 1.0   // source seconds consumed per timeline second
     var muted: Bool = false
+    var gain: Double = 1.0    // audio volume, linear (1 = unity, 0…2)
     var fadeIn: Double = 0    // audio fade lengths, timeline seconds
     var fadeOut: Double = 0
     var linkId: UUID?    // clips sharing a linkId move/blade together (multicam)
     var board: Board?    // storyboard panel content
     var newShot: Bool = false  // storyboard: this panel starts a new shot number
+    // REAPER sidecar linkage (clips on `.reaper` lanes only):
+    var reaperGUID: String?    // the .rpp item GUID this clip mirrors
+    var reaperGhost: Bool = false  // opaque item (MIDI etc.) — visible, not playable
+    var reaperName: String?    // item NAME from the .rpp (label for foreign/ghost items)
 
     var end: Double { start + duration }
     /// Source seconds this clip consumes (constant under time stretch).
@@ -451,7 +492,8 @@ struct Clip: Codable, Equatable, Identifiable {
 
     enum CodingKeys: String, CodingKey {
         case id, kind, mediaId, track, start, srcIn, duration, speed,
-             muted, fadeIn, fadeOut, linkId, board, newShot
+             muted, gain, fadeIn, fadeOut, linkId, board, newShot,
+             reaperGUID, reaperGhost, reaperName
     }
     init(from decoder: Decoder) throws {
         let c = try decoder.container(keyedBy: CodingKeys.self)
@@ -465,11 +507,15 @@ struct Clip: Codable, Equatable, Identifiable {
         duration = try c.decodeIfPresent(Double.self, forKey: .duration) ?? 1
         speed = try c.decodeIfPresent(Double.self, forKey: .speed) ?? 1
         muted = try c.decodeIfPresent(Bool.self, forKey: .muted) ?? false
+        gain = try c.decodeIfPresent(Double.self, forKey: .gain) ?? 1
         fadeIn = try c.decodeIfPresent(Double.self, forKey: .fadeIn) ?? 0
         fadeOut = try c.decodeIfPresent(Double.self, forKey: .fadeOut) ?? 0
         linkId = try c.decodeIfPresent(UUID.self, forKey: .linkId)
         board = try c.decodeIfPresent(Board.self, forKey: .board)
         newShot = try c.decodeIfPresent(Bool.self, forKey: .newShot) ?? false
+        reaperGUID = try c.decodeIfPresent(String.self, forKey: .reaperGUID)
+        reaperGhost = try c.decodeIfPresent(Bool.self, forKey: .reaperGhost) ?? false
+        reaperName = try c.decodeIfPresent(String.self, forKey: .reaperName)
     }
 }
 
@@ -519,6 +565,7 @@ extension ProjectModel {
         case .video(let i): return tracks.indices.contains(i) ? tracks[i].hue : 0
         case .storyboard:   return Self.storyboardHue
         case .fusion:       return 0
+        case .reaper:       return Self.reaperHue
         }
     }
 
@@ -536,12 +583,19 @@ extension ProjectModel {
     /// not stored in `tracks`).
     var hasStoryboard: Bool { clips.contains { $0.kind == .storyboard } }
 
+    /// True when the project is linked to a REAPER sidecar (`<name>.rpp`
+    /// beside the bundle, mirrored by the green reaper lanes).
+    var hasReaper: Bool { !reaperTracks.isEmpty }
+
     /// The lanes shown in the timeline/viewer, top to bottom: the storyboard
-    /// lane (if any panels exist) is pinned on top, then video tracks in index
-    /// order. Views index into this to map a row to a `TrackRef`.
+    /// lane (if any panels exist) is pinned on top, then the green REAPER
+    /// sidecar lanes, then video tracks in index order. Views index into this
+    /// to map a row to a `TrackRef`. (The Fusion band sits above all lanes by
+    /// geometry, so "below fusion and storyboard" holds.)
     var laneRefs: [TrackRef] {
         var rows: [TrackRef] = []
         if hasStoryboard { rows.append(.storyboard) }
+        for i in reaperTracks.indices { rows.append(.reaper(i)) }
         for i in tracks.indices { rows.append(.video(i)) }
         return rows
     }
@@ -742,7 +796,8 @@ func audioGain(_ clip: Clip, at t: Double) -> Double {
     var g = 1.0
     if clip.fadeIn > 0.001 { g = min(g, (t - clip.start) / clip.fadeIn) }
     if clip.fadeOut > 0.001 { g = min(g, (clip.end - t) / clip.fadeOut) }
-    return max(0, min(1, g))
+    // The fade envelope scales by the clip's own volume (0…2 linear).
+    return max(0, min(1, g)) * max(0, clip.gain)
 }
 
 func timecodeString(frame: Int, fps: Double) -> String {
diff --git a/sequencer/Sources/Sequencer/PerfTest.swift b/sequencer/Sources/Sequencer/PerfTest.swift
index af76a2f20c380ece79137f6731bfe36fc9290b08..26ae4f026676a51777fa39a0f4512b77052efad0 100644
--- a/sequencer/Sources/Sequencer/PerfTest.swift
+++ b/sequencer/Sources/Sequencer/PerfTest.swift
@@ -170,3 +170,247 @@ func runPerfTest(path: String) {
     }
     exit(0)
 }
+
+/// Zoom-transient harness: `sequencer --snapzoom <file.sq> <ppsA> <ppsB> [originSec] [pumpSec] [outPrefix]`.
+/// Pumps generation at ppsA, captures the settled ppsA frame, switches to ppsB
+/// and captures the immediate next draw (the cold zoom frame — the parallel
+/// direct path), then draws until warm and captures the settled ppsB frame.
+/// `<prefix>-a.png`, `<prefix>-transient.png`, `<prefix>-settled.png`: the
+/// transient and settled ppsB frames must be pixel-identical by design.
+@MainActor
+func runSnapZoom(args: [String]) {
+    let path = args[0]
+    let ppsA = args.count > 1 ? Double(args[1]) ?? 16 : 16
+    let ppsB = args.count > 2 ? Double(args[2]) ?? 8 : 8
+    let origin = args.count > 3 ? Double(args[3]) ?? 0 : 0
+    let pump = args.count > 4 ? Double(args[4]) ?? 15 : 15
+    let prefix = args.count > 5 ? args[5] : "/tmp/seq-snapzoom"
+
+    let url = URL(fileURLWithPath: path)
+    var isDir: ObjCBool = false
+    FileManager.default.fileExists(atPath: url.path, isDirectory: &isDir)
+    let jsonURL = isDir.boolValue ? url.appendingPathComponent("project.json") : url
+    guard let data = try? Data(contentsOf: jsonURL),
+          let doc = try? JSONDecoder().decode(SequencerDocument.self, from: data) else {
+        print("snapzoom: could not read \(jsonURL.path)"); exit(1)
+    }
+    let ctx = DocumentContext.headless
+    ctx.session.apply(doc.view)
+    ctx.session.showFilmstrips = true
+    ctx.store.replaceForTest(doc.project)
+
+    let W: CGFloat = 1600, H: CGFloat = 360
+    let timeline = TimelineView(frame: NSRect(x: 0, y: 0, width: W, height: H))
+    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: W, height: H),
+                          styleMask: [.borderless], backing: .buffered, defer: false)
+    window.contentView = timeline
+    timeline.testSetPxPerSecond(ppsA)
+    timeline.testSetOrigin(origin)
+
+    MediaPipeline.shared.ensureDerivedAssets(for: doc.project)
+    print("snapzoom: pumping \(pump)s at pps \(ppsA)…")
+    let rep = timeline.bitmapImageRepForCachingDisplay(in: timeline.bounds)!
+    let deadline = Date().addingTimeInterval(pump)
+    while Date() < deadline {
+        timeline.cacheDisplay(in: timeline.bounds, to: rep)
+        RunLoop.current.run(until: Date().addingTimeInterval(0.3))
+    }
+    func write(_ r: NSBitmapImageRep, _ name: String) {
+        guard let png = r.representation(using: .png, properties: [:]) else {
+            print("snapzoom: PNG encode failed"); exit(1)
+        }
+        try? png.write(to: URL(fileURLWithPath: "\(prefix)-\(name).png"))
+    }
+    // Settled ppsA frame.
+    timeline.cacheDisplay(in: timeline.bounds, to: rep)
+    write(rep, "a")
+    // The zoom: same anchor math as TimelineView.zoom(by:anchorX:) at the view
+    // center, then capture the FIRST frame drawn after the change.
+    let anchorX = W / 2
+    let anchorSec = origin + Double(anchorX - 26) / ppsA
+    timeline.testSetPxPerSecond(ppsB)
+    timeline.testSetOrigin(anchorSec - Double(anchorX - 26) / ppsB)
+    let transient = timeline.bitmapImageRepForCachingDisplay(in: timeline.bounds)!
+    timeline.cacheDisplay(in: timeline.bounds, to: transient)
+    write(transient, "transient")
+    // Settle: draw until the tile cache is warm, then capture.
+    for _ in 0..<12 {
+        timeline.cacheDisplay(in: timeline.bounds, to: rep)
+        RunLoop.current.run(until: Date().addingTimeInterval(0.05))
+    }
+    let settled = timeline.bitmapImageRepForCachingDisplay(in: timeline.bounds)!
+    timeline.cacheDisplay(in: timeline.bounds, to: settled)
+    write(settled, "settled")
+    print("snapzoom: wrote \(prefix)-{a,transient,settled}.png")
+    exit(0)
+}
+
+/// Pinch-stream transient detector:
+/// `sequencer --snappinch <file.sq> [ppsCenter] [originSec] [steps] [outPrefix]`.
+/// Simulates a continuous zoom gesture (pps swings ×0.67…×1.5 like a real
+/// magnify stream). Every step draws the frame TWICE with identical state —
+/// the first is the "live" cold frame, the second an immediate re-render —
+/// and any byte difference between them is a transient rendering bug. Offending
+/// pairs are written as `<prefix>-<step>-{live,again}.png`.
+@MainActor
+func runSnapPinch(args: [String]) {
+    let path = args[0]
+    let ppsC = args.count > 1 ? Double(args[1]) ?? 16 : 16
+    let origin = args.count > 2 ? Double(args[2]) ?? 0 : 0
+    let steps = args.count > 3 ? Int(args[3]) ?? 240 : 240
+    let prefix = args.count > 4 ? args[4] : "/tmp/seq-snappinch"
+
+    let url = URL(fileURLWithPath: path)
+    var isDir: ObjCBool = false
+    FileManager.default.fileExists(atPath: url.path, isDirectory: &isDir)
+    let jsonURL = isDir.boolValue ? url.appendingPathComponent("project.json") : url
+    guard let data = try? Data(contentsOf: jsonURL),
+          let doc = try? JSONDecoder().decode(SequencerDocument.self, from: data) else {
+        print("snappinch: could not read \(jsonURL.path)"); exit(1)
+    }
+    let ctx = DocumentContext.headless
+    ctx.session.apply(doc.view)
+    ctx.session.showFilmstrips = true
+    ctx.store.replaceForTest(doc.project)
+
+    let W: CGFloat = 1600, H: CGFloat = 360
+    let timeline = TimelineView(frame: NSRect(x: 0, y: 0, width: W, height: H))
+    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: W, height: H),
+                          styleMask: [.borderless], backing: .buffered, defer: false)
+    window.contentView = timeline
+    timeline.testSetPxPerSecond(ppsC)
+    timeline.testSetOrigin(origin)
+
+    MediaPipeline.shared.ensureDerivedAssets(for: doc.project)
+    print("snappinch: pumping 12s at pps \(ppsC)…")
+    let rep = timeline.bitmapImageRepForCachingDisplay(in: timeline.bounds)!
+    let deadline = Date().addingTimeInterval(12)
+    while Date() < deadline {
+        timeline.cacheDisplay(in: timeline.bounds, to: rep)
+        RunLoop.current.run(until: Date().addingTimeInterval(0.3))
+    }
+
+    func pixels(_ r: NSBitmapImageRep) -> Data {
+        Data(bytes: r.bitmapData!, count: r.bytesPerRow * r.pixelsHigh)
+    }
+    func write(_ r: NSBitmapImageRep, _ name: String) {
+        try? r.representation(using: .png, properties: [:])?
+            .write(to: URL(fileURLWithPath: "\(prefix)-\(name).png"))
+    }
+    var bad = 0
+    for i in 0..<steps {
+        let phase = Double(i) / Double(steps) * 6 * .pi
+        let f = exp(sin(phase) * 0.4)
+        timeline.testSetPxPerSecond(ppsC * f)
+        timeline.testSetOrigin(origin)
+        // Spin the runloop a hair so async thumb/peak loads land BETWEEN
+        // steps (like vsync gaps in the GUI), not between the two draws.
+        RunLoop.current.run(until: Date().addingTimeInterval(0.005))
+        let live = timeline.bitmapImageRepForCachingDisplay(in: timeline.bounds)!
+        timeline.cacheDisplay(in: timeline.bounds, to: live)
+        let again = timeline.bitmapImageRepForCachingDisplay(in: timeline.bounds)!
+        timeline.cacheDisplay(in: timeline.bounds, to: again)
+        if pixels(live) != pixels(again) {
+            bad += 1
+            write(live, "\(i)-live")
+            write(again, "\(i)-again")
+            print("snappinch: step \(i) pps \(String(format: "%.2f", ppsC * f)) DIFFERS")
+            if bad >= 6 { break }
+        }
+    }
+    print(bad == 0 ? "snappinch: OK — \(steps) steps, no transient differences"
+                   : "snappinch: \(bad) differing step(s), pairs written to \(prefix)-*")
+    exit(bad == 0 ? 0 : 2)
+}
+
+/// Headless snapshot: `sequencer --snap <file.sq> [pps] [originSec] [pumpSec] [out.png]`.
+/// Renders a real project's timeline offscreen to a PNG, pumping the runloop so
+/// background filmstrip/peak generation and async thumb loads land first — a
+/// visual check of waveform/thumbnail rendering without the full GUI.
+@MainActor
+func runSnap(args: [String]) {
+    let path = args[0]
+    let pps = args.count > 1 ? Double(args[1]) ?? 40 : 40
+    let origin = args.count > 2 ? Double(args[2]) ?? 0 : 0
+    let pump = args.count > 3 ? Double(args[3]) ?? 25 : 25
+    let out = args.count > 4 ? args[4] : "/tmp/seq-snap.png"
+
+    let url = URL(fileURLWithPath: path)
+    var isDir: ObjCBool = false
+    FileManager.default.fileExists(atPath: url.path, isDirectory: &isDir)
+    let jsonURL = isDir.boolValue ? url.appendingPathComponent("project.json") : url
+    guard let data = try? Data(contentsOf: jsonURL),
+          let doc = try? JSONDecoder().decode(SequencerDocument.self, from: data) else {
+        print("snap: could not read \(jsonURL.path)"); exit(1)
+    }
+    let ctx = DocumentContext.headless
+    ctx.session.apply(doc.view)
+    ctx.session.showFilmstrips = true
+    ctx.store.replaceForTest(doc.project)
+
+    let W: CGFloat = 1600, H: CGFloat = 360
+    let timeline = TimelineView(frame: NSRect(x: 0, y: 0, width: W, height: H))
+    let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: W, height: H),
+                          styleMask: [.borderless], backing: .buffered, defer: false)
+    window.contentView = timeline
+    timeline.testSetPxPerSecond(pps)
+    timeline.testSetOrigin(origin)
+
+    MediaPipeline.shared.ensureDerivedAssets(for: doc.project)
+    print("snap: pumping \(pump)s for generation…")
+    let deadline = Date().addingTimeInterval(pump)
+    let rep = timeline.bitmapImageRepForCachingDisplay(in: timeline.bounds)!
+    let gctx = NSGraphicsContext(bitmapImageRep: rep)!
+    while Date() < deadline {
+        NSGraphicsContext.saveGraphicsState()
+        NSGraphicsContext.current = gctx
+        timeline.testSetOrigin(origin)
+        timeline.testRedraw()   // drives fine-window requests + thumb/peak loads
+        NSGraphicsContext.restoreGraphicsState()
+        RunLoop.current.run(until: Date().addingTimeInterval(0.3))
+    }
+    // Optional 6th arg: leave a gesture mid-drag so the offset readout shows.
+    let gesture = args.count > 5 ? args[5] : ""
+    if !gesture.isEmpty {
+        ctx.session.snapping = false
+        let cands = doc.project.clips
+            .filter { $0.track == .video(0) && $0.kind == .video && $0.start >= origin + 0.3 }
+            .sorted { $0.start < $1.start }
+        if let c = cands.first {
+            func laneY(_ row: Int) -> CGFloat { timeline.testLaneMidY(row) }
+            func win(_ vx: CGFloat, _ vy: CGFloat) -> NSPoint { NSPoint(x: vx, y: H - vy) }
+            func ev(_ t: NSEvent.EventType, _ p: NSPoint, _ f: NSEvent.ModifierFlags) -> NSEvent {
+                NSEvent.mouseEvent(with: t, location: p, modifierFlags: f, timestamp: 0,
+                    windowNumber: window.windowNumber, context: nil, eventNumber: 0,
+                    clickCount: 1, pressure: 1)!
+            }
+            let opt: NSEvent.ModifierFlags = (gesture == "slip" || gesture.hasPrefix("ripple")) ? [.option] : []
+            let x0 = timeline.testXFor(c.start), x1 = timeline.testXFor(c.end)
+            let downX: CGFloat = gesture == "slip"
+                ? min(x0 + 40, (x0 + x1) / 2)   // well inside the body, on-screen
+                : x1 - 3
+            timeline.mouseDown(with: ev(.leftMouseDown, win(downX, laneY(0)), opt))
+            timeline.mouseDragged(with: ev(.leftMouseDragged,
+                win(downX + CGFloat(1.5 * pps), laneY(0)), opt))
+            print("snap: simulated \(gesture) → drag \(timeline.testDragInfo()) at downX \(downX), laneY \(laneY(0)), clip [\(c.start),\(c.end)]")
+            // Hold the drag open and pump so the edit-fine (per-frame) window
+            // generates and the frames appear under the drag.
+            let d2 = Date().addingTimeInterval(6)
+            while Date() < d2 {
+                NSGraphicsContext.saveGraphicsState()
+                NSGraphicsContext.current = gctx
+                timeline.testRedraw()
+                NSGraphicsContext.restoreGraphicsState()
+                RunLoop.current.run(until: Date().addingTimeInterval(0.2))
+            }
+        }
+    }
+    // Final render to the bitmap and write PNG.
+    timeline.cacheDisplay(in: timeline.bounds, to: rep)
+    guard let png = rep.representation(using: .png, properties: [:]) else {
+        print("snap: PNG encode failed"); exit(1)
+    }
+    try? png.write(to: URL(fileURLWithPath: out))
+    print("snap: wrote \(out)")
+    exit(0)
+}
diff --git a/sequencer/Sources/Sequencer/PlaybackController.swift b/sequencer/Sources/Sequencer/PlaybackController.swift
index 732d4a8a88ad61f83b0f2931b4e4e111ee7ce067..1f872963dd8186e17dfd86d3c72259110e75420a 100644
--- a/sequencer/Sources/Sequencer/PlaybackController.swift
+++ b/sequencer/Sources/Sequencer/PlaybackController.swift
@@ -176,6 +176,20 @@ final class PlaybackController {
         ctx.players.sync(force: false)
     }
 
+    /// The playhead half of `shift(by:)` with NO player sync: for ripple edits
+    /// that slide content and playhead together. Call BEFORE the model mutate,
+    /// so the `.projectChanged`-triggered player sync only ever sees the new
+    /// playhead against the new model. Shifting after the mutate would let
+    /// that sync run with a stale playhead and drift-reseek every audio
+    /// player — an audible dropout for an edit that changed nothing audible.
+    func shiftBeforeEdit(by delta: Double) {
+        let target = max(0, playhead + delta)
+        pausedPlayhead = target
+        anchorHost = CACurrentMediaTime()
+        anchorTime = target
+        ctx.notify.post(name: .playheadChanged, object: nil)
+    }
+
     // MARK: - Loop / cycle range (I / O / C)
 
     /// Mark the in point at the playhead. A collapsed range (out ≤ in) drops
@@ -249,12 +263,53 @@ final class TrackPlayer {
     /// worse than a few frames of drift, so they get wide thresholds and a
     /// deep buffer (their originals live on the NAS).
     var lenientSync = false
+    /// Drift beyond this triggers a hard resync (an audible/visible hiccup).
+    /// Video keeps the tight default; pure audio clips go wide (0.30); a video
+    /// clip's original-audio player sits between — loose enough not to blip
+    /// constantly, tight enough that lipsync stays under ~a few frames.
+    var driftTolerance = 0.08
+    var resyncGap = 0.5
     private var currentChunkVersion = -1
     private var lastChunkSwap: Double = 0
     var itemFailed = false
     private var seekInFlight = false
     private var pendingSeek: Double?
     private var lastResync: Double = 0
+    private var lastSeekCompleted: Double = 0
+    private var lastInstall: Double = 0
+
+    /// True while the player can't be trusted to be PRESENTING the frame at
+    /// its reported time: a seek is in flight or just completed, or a fresh
+    /// item was just installed. `currentTime()` updates the moment a seek
+    /// lands, but the layer keeps showing the PREVIOUS decoded picture until
+    /// the new frame decodes — revealing the layer in that gap flashes the
+    /// frame you scrubbed FROM (an "earlier part of the video"). The grace
+    /// windows cover the decode; the viewer holds its stand-in until settled.
+    var isSettling: Bool {
+        if seekInFlight || pendingSeek != nil { return true }
+        let now = CACurrentMediaTime()
+        return now - lastSeekCompleted < 0.08 || now - lastInstall < 0.25
+    }
+
+    /// True right after replaceCurrentItem, while the player's internal queue
+    /// is busy installing — a synchronous `currentTime()` in that window
+    /// blocks the MAIN thread on the player-queue mutex (the FigPlayer…
+    /// `[hang]`s). Callers should skip time reads until it passes.
+    var recentlyInstalled: Bool { CACurrentMediaTime() - lastInstall < 0.3 }
+
+    /// The item's current time read from its CMTimebase — NEVER from
+    /// `player.currentTime()`, which dispatches to the player's internal queue
+    /// under the FigPlayer mutex. When that queue is busy (item install, route
+    /// scan, heavy load) the synchronous read parks the MAIN thread on the
+    /// mutex — the log's worst `[hang]`s, up to 4+ seconds mid-playback. The
+    /// timebase is the lock-free clock the render pipeline itself advances:
+    /// same value, no queue hop. nil when no item/timebase exists yet (fresh
+    /// install) — callers treat that as "unknown, skip the check".
+    var playedSeconds: Double? {
+        guard let tb = player.currentItem?.timebase else { return nil }
+        let t = CMTimebaseGetTime(tb).seconds
+        return t.isFinite ? t : nil
+    }
 
     init() {
         player.automaticallyWaitsToMinimizeStalling = false
@@ -278,9 +333,20 @@ final class TrackPlayer {
             }
             return
         }
-        // Audio files play their original directly (no chunked proxies).
+        // Audio files play from the local audio proxy when it exists (the
+        // original is a NAS read competing with chunk encodes), else the
+        // original. A LIVE item never swaps just because the proxy landed —
+        // that would blip the sound; the proxy is adopted at the next install
+        // (player teardown/re-entry, or any paused moment).
         if media.isAudio {
-            let url = media.url
+            let proxy = MediaPipeline.shared.audioProxyURL(for: media)
+            // Self-healing: if the extraction failed earlier (NAS was down at
+            // doc open), re-kick it now that the clip is actually playing.
+            // Deduped + backoff'd, so the per-tick call is cheap.
+            if proxy == nil { MediaPipeline.shared.ensureAudioProxy(for: media) }
+            let keepLive = player.rate != 0 && player.currentItem != nil
+                && currentSourceURL == media.url
+            let url = keepLive ? media.url : (proxy ?? media.url)
             if currentSourceURL != url || player.currentItem == nil {
                 replaceItem(AVPlayerItem(url: url), media: media, url: url, version: -1)
             }
@@ -329,15 +395,24 @@ final class TrackPlayer {
                     // while the proxy could show the frame now). Never swap to
                     // merely sharpen a still that's already on screen.
                     // Pending quality upgrades take effect on the next play/seek.
-                    let cur = player.currentTime().seconds
+                    // (Right after an install the timebase isn't meaningful yet
+                    // — assume on-time for that beat.)
+                    let cur = recentlyInstalled ? sourceTime
+                        : (playedSeconds ?? .nan)
                     let parkedOff = !cur.isFinite || abs(cur - sourceTime) > 0.5
                     swap = sharperProxy && had == nil
                         && (!ctx.chunks.originalPlayable(media: media) || parkedOff)
                 } else {
-                    // PLAYING: adopt the proxy the moment it covers the playhead
-                    // (a NAS original may stutter), throttled so rapid
-                    // completions don't hiccup the stream.
-                    swap = sharperProxy && now - lastChunkSwap > 3
+                    // PLAYING: swap ONLY to reveal a chunk the current item has
+                    // nothing for (a rescue/chunk just landed under the
+                    // playhead — the alternative is black or a NAS-stuttering
+                    // original). A mere quality upgrade is never worth
+                    // interrupting the stream — replaceCurrentItem on a live
+                    // player drops a beat of video AND stalls the main thread
+                    // on the player queue's mutex; sharpening waits for the
+                    // next pause/seek/cut. Throttled so rapid completions
+                    // can't chain hiccups.
+                    swap = sharperProxy && had == nil && now - lastChunkSwap > 3
                 }
             }
             // A failed stream is only worth re-swapping to recover DURING
@@ -351,7 +426,25 @@ final class TrackPlayer {
         }
         currentClipId = clip.id
         if player.currentItem?.status == .failed { itemFailed = true }
-        player.isMuted = clip.muted || !media.hasAudio
+        // Video players are ALWAYS muted: a video clip's sound comes from its
+        // own per-clip audio player reading the ORIGINAL file (see syncAudio).
+        // The proxy composition's audio is full of holes (uncovered chunks are
+        // silent) and every item swap would drop it — the exact "audio cuts
+        // out at playback start" bug.
+        player.isMuted = true
+    }
+
+    /// Audio role for a VIDEO clip: play the original file's sound through an
+    /// audio-only composition (`AudioAssetCache`), never the proxy composition.
+    /// The item survives clip changes within the same media (a cut into another
+    /// clip of the same file just seeks), and is untouched by chunk/proxy
+    /// churn — so proxy landings can't cut the sound out.
+    func setAudioOnly(_ clip: Clip, media: MediaItem, asset: AVAsset) {
+        if currentMediaKey != media.cacheKey || player.currentItem == nil {
+            replaceItem(AVPlayerItem(asset: asset), media: media, url: nil, version: -1)
+        }
+        currentClipId = clip.id
+        if player.currentItem?.status == .failed { itemFailed = true }
     }
 
     private func replaceItem(_ item: AVPlayerItem, media: MediaItem, url: URL?, version: Int) {
@@ -377,6 +470,42 @@ final class TrackPlayer {
         itemFailed = false
         seekInFlight = false
         pendingSeek = nil
+        lastInstall = CACurrentMediaTime()
+    }
+
+    /// Host time (CACurrentMediaTime seconds) of the armed sample-accurate
+    /// start, if one is scheduled. See `armStart`.
+    private var armedStartHost: Double = -1
+
+    /// Sample-accurate deferred start for an upcoming clip whose in-point sits
+    /// too close to the FILE start to pre-roll through: the usual trick — run
+    /// the player silently from one lookahead before the in-point — needs
+    /// source material there, and when `srcIn ≈ 0` the old clamped seek left
+    /// the player running AHEAD of schedule, so the clip's first beats were
+    /// skipped (or a drift reseek fired mid-entry) — audibly, on a music loop
+    /// seam. Instead: anchor the player's timebase so rendering of
+    /// `sourceTime` begins exactly `inHost` seconds from now (the boundary),
+    /// which AVPlayer honors sample-accurately once the item is ready.
+    /// (`automaticallyWaitsToMinimizeStalling` is already false — required.)
+    func armStart(sourceTime: Double, rate: Double, inHost: Double) {
+        guard let item = player.currentItem else { return }
+        guard item.status == .readyToPlay else {
+            // Not decodable yet: park on the in-point so the eventual arm (or
+            // worst-case catch-up start) is already positioned.
+            if player.rate != 0 { player.rate = 0 }
+            coalescedSeek(to: sourceTime)
+            return
+        }
+        let boundary = CACurrentMediaTime() + inHost
+        // Already armed at this boundary (steady playback recomputes the same
+        // host time each tick) — leave the anchored timebase alone. A seek or
+        // rate change moves the boundary and re-arms; a pause routes the sync
+        // pass away from here, which unwinds the arm.
+        if abs(boundary - armedStartHost) < 0.005 { return }
+        armedStartHost = boundary
+        player.setRate(Float(rate), time: time(sourceTime),
+                       atHostTime: CMTime(seconds: boundary,
+                                          preferredTimescale: 1_000_000_000))
     }
 
     func syncTime(expected: Double, rate: Double, force: Bool) {
@@ -385,36 +514,67 @@ final class TrackPlayer {
             if player.rate != 0 { player.rate = 0 }
             coalescedSeek(to: expected)
         } else {
-            let actual = player.currentTime().seconds
             let now = CACurrentMediaTime()
             // A hard zero-tolerance seek is an audible/visible hiccup, so it
-            // only fires on real drift — and audio (lenient) tolerates much
-            // more drift before interrupting a smooth stream.
-            let drifted = abs(actual - expected) > (lenientSync ? 0.30 : 0.08)
-            let resyncGap = lenientSync ? 2.0 : 0.5
+            // only fires on real drift — thresholds are per-role
+            // (driftTolerance/resyncGap), audio wider than video. Right after
+            // an install the item hasn't been seeked into position yet, and an
+            // absent timebase means "unknown" — both skip the drift check.
+            let drifted = recentlyInstalled ? false
+                : playedSeconds.map { abs($0 - expected) > driftTolerance } ?? false
             if force || player.rate != Float(rate) || (drifted && now - lastResync > resyncGap) {
                 lastResync = now
+                let issueHost = CACurrentMediaTime()
+                // The transport rate at issue time: the completion bails if the
+                // user changed it while the seek was in flight. (`rate` itself
+                // can't be compared against the transport — it's premultiplied
+                // by clip.speed.)
+                let transportRate = ctx.playback.rate
                 player.seek(to: time(expected), toleranceBefore: .zero, toleranceAfter: .zero) { [weak self] _ in
-                    guard let self, ctx.playback.rate == rate else { return }
-                    if rate > 0 {
-                        self.player.playImmediately(atRate: Float(rate))
-                    } else {
+                    guard let self else { return }
+                    self.lastSeekCompleted = CACurrentMediaTime()
+                    guard self.ctx.playback.rate == transportRate else { return }
+                    // A host-anchored start requires a READY item. The seek can
+                    // complete SYNCHRONOUSLY (inline, right here) when the
+                    // current item isn't `.readyToPlay` — a just-installed audio
+                    // item on a `force` resync after a proxy/media landing, or a
+                    // failed item — because there's nothing to seek. On such an
+                    // item `setRate:time:atHostTime:` RAISES an NSException,
+                    // which is uncaught in Swift → abort() (the crash). Fall back
+                    // to a plain rate set (never throws); the next 60 Hz tick
+                    // re-anchors to the host clock once the item is ready.
+                    // (`armStart` takes the same `.readyToPlay` precaution.)
+                    guard let item = self.player.currentItem,
+                          item.status == .readyToPlay else {
                         self.player.rate = Float(rate)
+                        return
                     }
+                    // Anchor to the host clock, compensating the seek's own
+                    // latency. `playImmediately` here used to anchor the
+                    // ISSUE-time source position at COMPLETION time, leaving
+                    // every clip entry a frame or two behind schedule — under
+                    // driftTolerance, so it was never corrected, and playback
+                    // visibly disagreed with paused frame-stepping.
+                    let host = CACurrentMediaTime()
+                    self.player.setRate(Float(rate),
+                                        time: self.time(expected + (host - issueHost) * rate),
+                                        atHostTime: CMTime(seconds: host,
+                                                           preferredTimescale: 1_000_000_000))
                 }
             }
         }
     }
 
     private func coalescedSeek(to t: Double) {
-        let current = player.currentTime().seconds
-        if abs(current - t) < 0.004 { return }
+        if !recentlyInstalled, let current = playedSeconds,
+           abs(current - t) < 0.004 { return }
         if seekInFlight { pendingSeek = t; return }
         seekInFlight = true
         player.seek(to: time(t), toleranceBefore: .zero, toleranceAfter: .zero) { [weak self] _ in
             DispatchQueue.main.async {
                 guard let self else { return }
                 self.seekInFlight = false
+                self.lastSeekCompleted = CACurrentMediaTime()
                 if let p = self.pendingSeek {
                     self.pendingSeek = nil
                     self.coalescedSeek(to: p)
@@ -422,8 +582,15 @@ final class TrackPlayer {
                     // Landed on the target frame. While paused nothing else
                     // ticks the viewer, so tell it to re-evaluate: the player
                     // is now showing the right frame and can replace the
-                    // stand-in filmstrip.
+                    // stand-in filmstrip. The immediate post lands inside the
+                    // settle grace (the layer may still present the OLD
+                    // frame); the delayed one is what actually reveals — after
+                    // the grace, when the new frame is truly on the layer.
                     NotificationCenter.default.post(name: .viewerNeedsRefresh, object: nil)
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) {
+                        NotificationCenter.default.post(name: .viewerNeedsRefresh,
+                                                        object: nil)
+                    }
                 }
             }
         }
@@ -466,9 +633,9 @@ final class VideoTrackPlayer {
 
     func sync(ref: TrackRef, playhead: Double, rate: Double,
               playheadMoved: Bool, force: Bool) {
-        let project = ctx.store.project
-        let cur = project.clipAt(track: ref, time: playhead, kind: .video)
-        let media = cur.flatMap { project.media($0.mediaId) }
+        let index = ctx.store.index
+        let cur = index.clipAt(track: ref, time: playhead, kind: .video)
+        let media = cur.flatMap { index.media($0.mediaId) }
 
         // FLIP: the front is showing the wrong (previous) clip, but the back was
         // prerolled to exactly the clip now under the playhead → hand over.
@@ -491,18 +658,32 @@ final class VideoTrackPlayer {
         // prerolls the PREVIOUS one at its last, so a backwards cut is just as
         // gapless.
         var buffering = false
-        if rate >= 0, let next = nextDifferentClip(on: ref, after: playhead, current: cur),
+        if rate >= 0,
+           let next = index.nextDifferentClip(on: ref, after: playhead,
+                                              currentMedia: cur?.mediaId),
            next.start - playhead <= Self.preroll,
-           let nextMedia = project.media(next.mediaId) {
+           let nextMedia = index.media(next.mediaId) {
             if back.currentClipId != next.id {
                 back.setClip(next, media: nextMedia, sourceTime: next.srcIn)
             }
             back.player.isMuted = true
-            back.syncTime(expected: next.srcIn, rate: 0, force: false)
+            if rate > 0, next.start - playhead <= 1.0 {
+                // Final approach: arm a host-anchored start at the cut, so by
+                // the time the flip tick swaps layers the (still muted) player
+                // is already RUNNING exactly on schedule — the old park-then-
+                // play-at-flip start lagged by the flip seek's latency, a
+                // frame or two that driftTolerance never repaid.
+                back.armStart(sourceTime: next.srcIn, rate: rate * next.speed,
+                              inHost: (next.start - playhead) / rate)
+            } else {
+                back.syncTime(expected: next.srcIn, rate: 0, force: false)
+            }
             buffering = true
-        } else if rate < 0, let prev = prevDifferentClip(on: ref, before: playhead, current: cur),
+        } else if rate < 0,
+                  let prev = index.prevDifferentClip(on: ref, before: playhead,
+                                                     currentMedia: cur?.mediaId),
                   playhead - prev.end <= Self.preroll,
-                  let prevMedia = project.media(prev.mediaId) {
+                  let prevMedia = index.media(prev.mediaId) {
             let tail = max(prev.srcIn, prev.sourceTime(at: prev.end) - 0.05)
             if back.currentClipId != prev.id {
                 back.setClip(prev, media: prevMedia, sourceTime: tail)
@@ -515,7 +696,7 @@ final class VideoTrackPlayer {
             back.setClip(nil, media: nil)   // release the idle buffer
         }
 
-        warmBoundaryFrames(ref: ref, playhead: playhead, project: project)
+        warmBoundaryFrames(ref: ref, playhead: playhead, index: index)
     }
 
     /// Warm the exact frames every nearby cut will need into the RAM frame
@@ -523,11 +704,9 @@ final class VideoTrackPlayer {
     /// the beat between "boundary crossed" and "player ready" shows the real
     /// frame instead of a filmstrip thumb or a spinner. Self-deduping (the
     /// cache remembers, decodes are backgrounded), so per-tick calls are cheap.
-    private func warmBoundaryFrames(ref: TrackRef, playhead: Double, project: ProjectModel) {
-        for clip in project.clips where clip.track == ref && clip.kind == .video {
-            guard abs(clip.start - playhead) <= Self.warmRadius
-                    || abs(clip.end - playhead) <= Self.warmRadius,
-                  let media = project.media(clip.mediaId), !media.isAudio else { continue }
+    private func warmBoundaryFrames(ref: TrackRef, playhead: Double, index: ClipIndex) {
+        for clip in index.boundaryClips(on: ref, near: playhead, radius: Self.warmRadius) {
+            guard let media = index.media(clip.mediaId), !media.isAudio else { continue }
             if abs(clip.start - playhead) <= Self.warmRadius {
                 FrameCache.shared.warm(
                     mediaKey: media.cacheKey, at: clip.srcIn,
@@ -542,33 +721,90 @@ final class VideoTrackPlayer {
         }
     }
 
-    /// The next clip on this track (in time) whose media differs from `current`
-    /// — i.e. the next cut that would otherwise flash. Same-media continuations
-    /// don't need a buffer.
-    private func nextDifferentClip(on ref: TrackRef, after t: Double,
-                                   current: Clip?) -> Clip? {
-        ctx.store.project.clips
-            .filter { $0.track == ref && $0.kind == .video && $0.start > t + 1e-6
-                      && $0.mediaId != current?.mediaId }
-            .min { $0.start < $1.start }
-    }
-
-    /// The mirror for reverse playback: the previous clip (in time) whose media
-    /// differs — the cut a rewinding playhead will cross next.
-    private func prevDifferentClip(on ref: TrackRef, before t: Double,
-                                   current: Clip?) -> Clip? {
-        ctx.store.project.clips
-            .filter { $0.track == ref && $0.kind == .video && $0.end < t + 1e-6
-                      && $0.mediaId != current?.mediaId }
-            .max { $0.end < $1.end }
-    }
-
     func clear() {
         a.player.replaceCurrentItem(with: nil)
         b.player.replaceCurrentItem(with: nil)
     }
 }
 
+/// Audio-only compositions of original media files, one per media, shared
+/// app-wide (keyed by cacheKey, so identical files dedupe). A video clip's
+/// sound plays from here instead of the proxy composition: the original's
+/// audio is always complete (no uncovered-chunk silence) and cheap to stream
+/// even off the NAS, and building the item WITHOUT the 4K video track keeps
+/// AVPlayer from decoding pictures nobody renders.
+///
+/// `asset(for:)` returns nil until the async track load lands (first call
+/// kicks it; `.mediaStatusChanged` fires on completion so the audio sync runs
+/// again). Main-thread only.
+enum AudioAssetCache {
+    private nonisolated(unsafe) static var assets: [String: AVAsset] = [:]
+    private nonisolated(unsafe) static var building = Set<String>()
+    private nonisolated(unsafe) static var failedAt: [String: Double] = [:]
+    /// Keys whose cached comp reads the LOCAL audio proxy (vs the NAS original).
+    private nonisolated(unsafe) static var fromProxy = Set<String>()
+    /// Proxies that failed to load — never retried (we extracted them
+    /// ourselves; a bad one means fall back to the original for good).
+    private nonisolated(unsafe) static var proxyBad = Set<String>()
+
+    static func asset(for media: MediaItem) -> AVAsset? {
+        let key = media.cacheKey
+        let proxy = proxyBad.contains(key) ? nil
+            : MediaPipeline.shared.audioProxyURL(for: media)
+        if let a = assets[key] {
+            // Built from the NAS original, and the local proxy has since
+            // landed: rebuild from the proxy in the background. The old comp
+            // keeps playing — a player only adopts the new one at its next
+            // item install (clip re-entry / pause), never mid-stream.
+            if let proxy, !fromProxy.contains(key), !building.contains(key) {
+                build(key: key, url: proxy, isProxy: true)
+            }
+            return a
+        }
+        guard !building.contains(key) else { return nil }
+        // No proxy on disk yet: re-kick the extraction (deduped + backoff'd —
+        // covers a NAS that was down when the document opened).
+        if proxy == nil { MediaPipeline.shared.ensureAudioProxy(for: media) }
+        // A failed load (unmounted NAS) must NOT cache an empty composition —
+        // that would be permanent silence. Back off and retry instead.
+        if let f = failedAt[key], CACurrentMediaTime() - f < 5 { return nil }
+        build(key: key, url: proxy ?? media.url, isProxy: proxy != nil)
+        return nil
+    }
+
+    private static func build(key: String, url: URL, isProxy: Bool) {
+        building.insert(key)
+        Task.detached(priority: .userInitiated) {
+            let source = AVURLAsset(url: url)
+            let comp = AVMutableComposition()
+            var ok = false
+            if let a = try? await source.loadTracks(withMediaType: .audio).first,
+               let dur = try? await source.load(.duration),
+               let t = comp.addMutableTrack(withMediaType: .audio,
+                                            preferredTrackID: kCMPersistentTrackID_Invalid) {
+                do {
+                    try t.insertTimeRange(CMTimeRange(start: .zero, duration: dur),
+                                          of: a, at: .zero)
+                    ok = true
+                } catch {}
+            }
+            DispatchQueue.main.async {
+                building.remove(key)
+                if ok {
+                    failedAt.removeValue(forKey: key)
+                    assets[key] = comp
+                    if isProxy { fromProxy.insert(key) } else { fromProxy.remove(key) }
+                    NotificationCenter.default.post(name: .mediaStatusChanged, object: nil)
+                } else if isProxy {
+                    proxyBad.insert(key)   // next call falls back to the original
+                } else {
+                    failedAt[key] = CACurrentMediaTime()
+                }
+            }
+        }
+    }
+}
+
 final class PlayerManager {
     /// The document context that owns this manager. Set at construction.
     unowned var ctx: DocumentContext!
@@ -578,6 +814,13 @@ final class PlayerManager {
     private(set) var audioPlayers: [UUID: TrackPlayer] = [:]
     private var lastSyncedPlayhead: Double = -1
 
+    /// REAPER mixdown playback (see syncAudio): the synthetic clip's stable
+    /// id, its fabricated MediaItem (Render/mix.wav is not project media),
+    /// and the render mtime the current player item was built from.
+    private let reaperMixClipId = UUID()
+    private var reaperMixMedia: MediaItem?
+    private var reaperMixLoadedMtime: Date?
+
     init() {
         // Paused-state updates: clip edits move content under the playhead,
         // and finished proxies should replace original/filmstrip playback.
@@ -646,15 +889,46 @@ final class PlayerManager {
     private static let audioLookahead = 1.0
     private static let audioLinger = 0.5
 
-    /// Layered audio: every audio clip near the playhead plays through its own
-    /// player, with the fade envelope applied as volume. Players for clips just
-    /// ahead of the playhead are kept running (silent) so cuts are seamless.
+    /// Layered audio: every sound-producing clip near the playhead — audio
+    /// clips AND video clips whose media has an audio stream — plays through
+    /// its own player, with the fade envelope applied as volume. Players for
+    /// clips just ahead of the playhead are kept running (silent) so cuts are
+    /// seamless. Video clips play their ORIGINAL file's audio (audio-only
+    /// composition), fully decoupled from proxy chunk coverage and item swaps.
     private func syncAudio(project: ProjectModel, playhead: Double, rate: Double,
                            playheadMoved: Bool, force: Bool) {
-        let windowed = project.clips.filter {
-            $0.kind == .audio
-                && playhead + Self.audioLookahead >= $0.start
-                && playhead - Self.audioLinger < $0.end
+        let index = ctx.store.index
+        var windowed = index.audibleClips(from: playhead - Self.audioLinger,
+                                          to: playhead + Self.audioLookahead)
+        // REAPER sidecar mixdown: once REAPER has rendered `Render/mix.wav`
+        // into the bundle, the reaper lanes play that processed mix — one
+        // synthetic clip pinned at t=0 — instead of their raw per-stem
+        // players. `reaperRenderReady` is a session memo maintained on focus
+        // edges (per-tick disk stats are banned here).
+        if ctx.session.reaperRenderReady, project.hasReaper,
+           let mixURL = ReaperLink.renderURL(ctx) {
+            windowed.removeAll { $0.track.isReaper }
+            // A re-render (new mtime) needs a fresh player item; the URL alone
+            // wouldn't change, so drop the player and let it rebuild below.
+            if reaperMixLoadedMtime != ctx.session.reaperRenderMtime {
+                reaperMixLoadedMtime = ctx.session.reaperRenderMtime
+                if let p = audioPlayers.removeValue(forKey: reaperMixClipId) {
+                    p.player.replaceCurrentItem(with: nil)
+                }
+                reaperMixMedia = nil
+            }
+            if reaperMixMedia?.path != mixURL.path {
+                var m = MediaItem(path: mixURL.path)
+                m.hasAudio = true
+                m.isAudio = true
+                reaperMixMedia = m
+            }
+            if let mixMedia = reaperMixMedia {
+                var mix = Clip(mediaId: mixMedia.id, track: .video(0),
+                               start: 0, srcIn: 0, duration: 86400, kind: .audio)
+                mix.id = reaperMixClipId
+                windowed.append(mix)
+            }
         }
         let windowedIds = Set(windowed.map(\.id))
         for (id, p) in audioPlayers where !windowedIds.contains(id) {
@@ -662,7 +936,16 @@ final class PlayerManager {
             audioPlayers.removeValue(forKey: id)
         }
         for clip in windowed {
-            guard let media = project.media(clip.mediaId) else { continue }
+            guard let media = index.media(clip.mediaId)
+                ?? (clip.id == reaperMixClipId ? reaperMixMedia : nil) else { continue }
+            let isVideo = clip.kind == .video
+            // A video clip's audio-only asset builds async on first request;
+            // until it lands there's simply no player for it yet.
+            var audioAsset: AVAsset?
+            if isVideo {
+                guard let a = AudioAssetCache.asset(for: media) else { continue }
+                audioAsset = a
+            }
             let ap: TrackPlayer
             if let existing = audioPlayers[clip.id] {
                 ap = existing
@@ -670,15 +953,41 @@ final class PlayerManager {
                 ap = TrackPlayer()
                 ap.ctx = ctx
                 ap.lenientSync = true
+                // Lipsync: a video clip's sound tracks its picture, so it gets
+                // tighter drift bounds than a free-standing audio clip.
+                ap.driftTolerance = isVideo ? 0.15 : 0.30
+                ap.resyncGap = isVideo ? 1.0 : 2.0
                 audioPlayers[clip.id] = ap
             }
-            let expected = clip.srcIn + (playhead - clip.start)
-            ap.setClip(clip, media: media, sourceTime: expected)
+            let expected = clip.sourceTime(at: playhead)
+            if isVideo, let audioAsset {
+                ap.setAudioOnly(clip, media: media, asset: audioAsset)
+            } else {
+                ap.setClip(clip, media: media, sourceTime: expected)
+            }
+            // An upcoming clip whose in-point is too close to the FILE start
+            // can't run the silent preroll (there's no material before the
+            // in-point to run through — `expected` would be negative and the
+            // clamped seek used to leave the player ahead of schedule, eating
+            // the clip's first beats). Arm a sample-accurate timebase start at
+            // the boundary instead. Forward playback only; reverse entry keeps
+            // the plain path.
+            let upcoming = rate > 0 && playhead < clip.start
+                && clip.srcIn < (Self.audioLookahead + 0.05) * clip.speed
             // audioGain is 0 outside [start, end], so a prerolled upcoming clip
-            // stays silent until its cut, then hands over with no gap.
-            ap.player.volume = Float(audioGain(clip, at: playhead))
-            if rate != 0 || playheadMoved || force {
-                ap.syncTime(expected: expected, rate: rate, force: force)
+            // stays silent until its cut, then hands over with no gap. An ARMED
+            // player at the file's very start renders nothing before the
+            // boundary, so its entry volume is safe to set in advance — the
+            // first samples sound at level instead of one 60 Hz tick late.
+            // (AVPlayer.volume is 0…1 — a boost gain >1 only fully applies on
+            // export; live playback clamps at unity.)
+            let gainAt = upcoming && clip.srcIn < 0.001 ? clip.start + 1e-4 : playhead
+            ap.player.volume = clip.muted ? 0 : Float(min(1, audioGain(clip, at: gainAt)))
+            if upcoming {
+                ap.armStart(sourceTime: clip.srcIn, rate: rate * clip.speed,
+                            inHost: (clip.start - playhead) / rate)
+            } else if rate != 0 || playheadMoved || force {
+                ap.syncTime(expected: expected, rate: rate * clip.speed, force: force)
             }
         }
     }
diff --git a/sequencer/Sources/Sequencer/ReaperExport.swift b/sequencer/Sources/Sequencer/ReaperExport.swift
new file mode 100644
index 0000000000000000000000000000000000000000..f974cad4a62b1cf2c5352715fabe34d0d47695e4
--- /dev/null
+++ b/sequencer/Sources/Sequencer/ReaperExport.swift
@@ -0,0 +1,855 @@
+import Foundation
+import AppKit
+
+/// Exports project audio into the REAPER sidecar.
+///
+/// The sidecar model (v2): "Export to REAPER" doesn't produce a throwaway
+/// project — it MOVES the exported clips onto green *reaper lanes* in the
+/// sequencer that mirror the `.rpp`'s tracks, item for item (joined by GUID).
+/// The `.rpp` (next to the `.sq` bundle) becomes the source of truth for those
+/// lanes: `ReaperLink.pull` re-reads it whenever it changes, and while REAPER
+/// is closed the sequencer may move reaper clips and `ReaperLink.push` writes
+/// the positions back surgically (via `RppFile`, which round-trips REAPER's
+/// own saves byte-for-byte).
+///
+/// Two artefacts per export:
+///  - **Stems** — one lossless WAV per clip, baked to the clip's exact source
+///    range, written INSIDE the `.sq` package (`Stems/`). The reaper-lane clip
+///    plays this stem (srcIn 0), so the timeline stays audible with REAPER
+///    closed and no render yet.
+///  - **Items** in the `.rpp` — `SOFFS 0`, `POSITION = start`,
+///    `LENGTH = duration`, `PLAYRATE = speed`; all seconds, no fps math. The
+///    item GUID **is the sequencer clip's UUID** — that's the sync join key.
+///
+/// First export creates the `.rpp` (with RENDER_* pointed back into the
+/// bundle — `Render/mix.wav` — so a render in REAPER lands where the
+/// sequencer plays it). Later exports APPEND to it: new stems, new items,
+/// clips migrate to the reaper lanes. A video clip with audio is muted in
+/// place and its audio splits onto the reaper lane; a pure audio clip moves
+/// wholesale. See [[reaper-rpp-format]].
+enum ReaperExport {
+
+    // MARK: - Errors
+
+    enum ReaperError: Error, LocalizedError {
+        case notSaved
+        case noFfmpeg
+        case nothingSelected
+        case nothingToExport
+        case missingMedia([String])
+        case bakeFailed(String)
+        case writeFailed(String)
+        case reaperOpen
+        case sidecarMissing
+        case sidecarUnreadable
+
+        var errorDescription: String? {
+            switch self {
+            case .notSaved:
+                return "Save the project first — REAPER export writes stems into "
+                    + "the .sq bundle and the .rpp next to it."
+            case .noFfmpeg:
+                return "ffmpeg was not found. Install it (e.g. `brew install ffmpeg`)."
+            case .nothingSelected:
+                return "Select the clips you want to export to REAPER first."
+            case .nothingToExport:
+                return "None of the selected clips have audio to export "
+                    + "(muted, or already on REAPER lanes)."
+            case .missingMedia(let names):
+                let list = names.map { "  • \($0)" }.joined(separator: "\n")
+                return "These sources could not be read, so their audio can't be "
+                    + "baked. Reconnect the drive or relink and try again:\n\n\(list)"
+            case .bakeFailed(let s):
+                return "ffmpeg failed while baking a stem.\n\n\(s)"
+            case .writeFailed(let s):
+                return "Could not write the REAPER project.\n\n\(s)"
+            case .reaperOpen:
+                return "REAPER is open. Close it first so the sidecar project "
+                    + "can be updated without losing edits."
+            case .sidecarMissing:
+                return "The sidecar .rpp is missing (was it moved or deleted?). "
+                    + "It should sit next to the .sq bundle."
+            case .sidecarUnreadable:
+                return "The sidecar .rpp could not be parsed."
+            }
+        }
+    }
+
+    // MARK: - Selection
+
+    /// Every audio-bearing, unmuted clip across all video tracks, sorted by
+    /// track then start. Clips already exported are naturally excluded: pure
+    /// audio clips MOVED to the reaper lanes, and split video clips are muted.
+    static func exportClips(_ project: ProjectModel) -> [Clip] {
+        let refs = Set(project.tracks.indices.map { TrackRef.video($0) })
+        return ExportPlan.audioClips(project: project, trackRefs: refs)
+            .sorted {
+                let (a, b) = ($0.track.videoIndex ?? 0, $1.track.videoIndex ?? 0)
+                return a != b ? a < b : $0.start < $1.start
+            }
+    }
+
+    /// Stable, collision-free stem filename: `NNN_source-name.wav`.
+    static func stemName(number: Int, clip: Clip, project: ProjectModel) -> String {
+        let base = project.media(clip.mediaId)?.url.deletingPathExtension().lastPathComponent ?? "clip"
+        return String(format: "%03d_%@.wav", number, sanitize(base))
+    }
+
+    // MARK: - The sidecar plan
+
+    /// Everything decided up front (on main, from a captured model) so the
+    /// bake + write can run off-main and the migration is deterministic.
+    struct SidecarPlan {
+        struct Entry {
+            var source: Clip          // the video-lane clip, as captured
+            var itemClipId: UUID      // reaper-lane clip id == .rpp item GUID
+            var stemFile: String      // filename inside Stems/
+            var reaperIndex: Int      // lane in plan.tracks
+            var isSplit: Bool         // video+audio → mute video, add audio clip
+            var startOverride: Double?  // drag-in drop position
+            /// The `.rpp` already contains this clip's item (a v1-era export:
+            /// item GUID == clip UUID) — don't bake or append, just marry the
+            /// clip to the existing item + stem under this GUID.
+            var adoptGUID: String?
+        }
+        var tracks: [ReaperTrack]     // final ProjectModel.reaperTracks
+        var newTrackIndices: [Int]    // indices in `tracks` that don't exist in the .rpp yet
+        var entries: [Entry]
+    }
+
+    /// Map clips onto reaper lanes: one lane per source video track, named
+    /// "V<n>", with a deterministic GUID — matching what `rppText` emits, so
+    /// create and append agree. `startNumber` numbers the stems.
+    static func buildPlan(project: ProjectModel, clips: [Clip], startNumber: Int) -> SidecarPlan {
+        var tracks = project.reaperTracks
+        var newIndices: [Int] = []
+        var laneFor: [Int: Int] = [:]   // source video index → reaper lane
+        var entries: [SidecarPlan.Entry] = []
+        for (i, clip) in clips.enumerated() {
+            let vi = clip.track.videoIndex ?? 0
+            let lane: Int
+            if let l = laneFor[vi] {
+                lane = l
+            } else if let existing = tracks.firstIndex(where: { $0.guid == trackGUID(vi) }) {
+                lane = existing; laneFor[vi] = existing
+            } else {
+                tracks.append(ReaperTrack(name: "V\(vi + 1)", guid: trackGUID(vi)))
+                lane = tracks.count - 1
+                newIndices.append(lane)
+                laneFor[vi] = lane
+            }
+            let media = project.media(clip.mediaId)
+            let isSplit = !(media?.isAudio ?? false)
+            entries.append(.init(
+                source: clip,
+                itemClipId: isSplit ? UUID() : clip.id,
+                stemFile: stemName(number: startNumber + i, clip: clip, project: project),
+                reaperIndex: lane,
+                isSplit: isSplit,
+                startOverride: nil,
+                adoptGUID: nil))
+        }
+        return SidecarPlan(tracks: tracks, newTrackIndices: newIndices, entries: entries)
+    }
+
+    /// The clip an entry puts on the reaper lane (also the shape its `.rpp`
+    /// item is generated from — same id, same geometry).
+    static func reaperClip(for entry: SidecarPlan.Entry, stemMediaId: UUID?,
+                           project: ProjectModel) -> Clip {
+        var c = entry.source
+        c.id = entry.itemClipId
+        c.kind = .audio
+        c.track = .reaper(entry.reaperIndex)
+        c.mediaId = stemMediaId
+        c.srcIn = 0                      // stem = exact source range
+        c.linkId = nil                   // reaper lanes don't join multicam groups
+        c.board = nil
+        c.muted = false
+        c.reaperGUID = entry.adoptGUID ?? itemGUID(entry.itemClipId)
+        c.reaperName = project.media(entry.source.mediaId)?.displayName
+        if let s = entry.startOverride { c.start = s }
+        return c
+    }
+
+    /// Apply the migration to the model (pure — testable headlessly).
+    /// `stems[itemClipId]` carries what the bake learned about each stem file.
+    static func applyMigration(_ model: inout ProjectModel, plan: SidecarPlan,
+                               stems: [UUID: (path: String, cacheKey: String, duration: Double)]) {
+        model.reaperTracks = plan.tracks
+        for entry in plan.entries {
+            guard let stem = stems[entry.itemClipId] else { continue }
+            var media = MediaItem(path: stem.path)
+            media.duration = stem.duration
+            media.hasAudio = true
+            media.isAudio = true
+            media.cacheKey = stem.cacheKey
+            // Dedup on re-export of the same stem path (overwrite bake).
+            if let i = model.media.firstIndex(where: { $0.path == stem.path }) {
+                media.id = model.media[i].id
+                model.media[i] = media
+            } else {
+                model.media.append(media)
+            }
+            let rc = reaperClip(for: entry, stemMediaId: media.id, project: model)
+            if entry.isSplit {
+                // Mute the video in place; its audio lives on the reaper lane now.
+                if let i = model.clips.firstIndex(where: { $0.id == entry.source.id }) {
+                    model.clips[i].muted = true
+                }
+                model.clips.append(rc)
+            } else if let i = model.clips.firstIndex(where: { $0.id == entry.source.id }) {
+                model.clips[i] = rc
+            }
+            // else: the clip vanished mid-bake — leave the item in the .rpp;
+            // the next pull imports it back as a foreign item. Self-healing.
+        }
+    }
+
+    // MARK: - Public entry (off-main; progress + completion on main)
+
+    static func run(ctx: DocumentContext,
+                    progress: @escaping (Double) -> Void,
+                    completion: @escaping (Result<URL, Error>) -> Void) {
+        // Capture everything that touches the document/model on the main thread.
+        guard let bundleURL = ctx.document?.fileURL else {
+            completion(.failure(ReaperError.notSaved)); return
+        }
+        let project = ctx.store.project
+        // Export only the selected clips (Export *Selection* to REAPER).
+        let selection = ctx.store.selection
+        guard !selection.isEmpty else {
+            completion(.failure(ReaperError.nothingSelected)); return
+        }
+        let clips = exportClips(project).filter { selection.contains($0.id) }
+        guard !clips.isEmpty else {
+            completion(.failure(ReaperError.nothingToExport)); return
+        }
+        // Append whenever a sidecar file already exists (even a v1-era one the
+        // model doesn't know about yet — its items get ADOPTED, not re-baked).
+        let appending = FileManager.default.fileExists(atPath: sidecarURL(bundleURL).path)
+        if appending && ReaperLink.reaperRunning {
+            // Rewriting a project REAPER may have open loses its edits.
+            completion(.failure(ReaperError.reaperOpen)); return
+        }
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                let (plan, stems, rppURL) = try export(
+                    project: project, clips: clips, bundleURL: bundleURL,
+                    appending: appending, progress: progress)
+                DispatchQueue.main.async {
+                    finishOnMain(ctx: ctx, plan: plan, stems: stems, rppURL: rppURL)
+                    completion(.success(rppURL))
+                }
+            } catch {
+                DispatchQueue.main.async { completion(.failure(error)) }
+            }
+        }
+    }
+
+    /// Drag-in append: one audio clip dropped onto a reaper lane. Bakes its
+    /// stem, appends its item to the `.rpp` at the drop position, migrates the
+    /// clip. (Video clips never get here — the drop is disallowed upstream.)
+    static func exportSingle(ctx: DocumentContext, clipId: UUID,
+                             toReaperIndex lane: Int, at start: Double,
+                             completion: @escaping (Result<URL, Error>) -> Void) {
+        guard let bundleURL = ctx.document?.fileURL else {
+            completion(.failure(ReaperError.notSaved)); return
+        }
+        guard !ReaperLink.reaperRunning else {
+            completion(.failure(ReaperError.reaperOpen)); return
+        }
+        let project = ctx.store.project
+        guard let clip = project.clip(clipId) else {
+            completion(.failure(ReaperError.nothingToExport)); return
+        }
+
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                let stemsDir = bundleURL.appendingPathComponent("Stems", isDirectory: true)
+                var plan = buildPlan(project: project, clips: [clip],
+                                     startNumber: nextStemNumber(in: stemsDir))
+                // The drop chose the lane and time — override the plan's mapping.
+                if plan.tracks.indices.contains(lane) {
+                    plan.entries[0].reaperIndex = lane
+                    // A brand-new lane the drop didn't target stays unused; drop it.
+                    if let created = plan.newTrackIndices.first, created != lane {
+                        plan.tracks.remove(at: created)
+                        plan.newTrackIndices = []
+                    }
+                }
+                plan.entries[0].startOverride = start
+                let rppURL0 = sidecarURL(bundleURL)
+                guard FileManager.default.fileExists(atPath: rppURL0.path) else {
+                    throw ReaperError.sidecarMissing
+                }
+                guard let rpp = RppProject.load(rppURL0) else {
+                    throw ReaperError.sidecarUnreadable
+                }
+                let (stems, rppURL) = try bakeAndWrite(
+                    project: project, plan: plan, bundleURL: bundleURL,
+                    existingRpp: rpp, progress: { _ in })
+                DispatchQueue.main.async {
+                    finishOnMain(ctx: ctx, plan: plan, stems: stems, rppURL: rppURL)
+                    completion(.success(rppURL))
+                }
+            } catch {
+                DispatchQueue.main.async { completion(.failure(error)) }
+            }
+        }
+    }
+
+    /// Shared tail: migrate the model (one undoable step), remember the file
+    /// state we authored, kick peak generation for the new stems — then force
+    /// a pull so the model reconciles against the file as REAPER sees it
+    /// (adopted v1 items, tracks reordered in REAPER, items we don't own yet).
+    private static func finishOnMain(ctx: DocumentContext, plan: SidecarPlan,
+                                     stems: [UUID: (path: String, cacheKey: String, duration: Double)],
+                                     rppURL: URL) {
+        ctx.store.mutate { model in
+            applyMigration(&model, plan: plan, stems: stems)
+        }
+        ctx.session.reaperDirty = false
+        ctx.session.reaperSyncedMtime = nil   // force the reconcile pull below
+        for media in ctx.store.project.media
+            where stems.values.contains(where: { $0.path == media.path }) {
+            MediaPipeline.shared.enqueueDerivedAssets(for: media)
+        }
+        ReaperLink.pull(ctx, force: true)
+    }
+
+    /// `<Project>.rpp`, beside the `.sq` bundle.
+    static func sidecarURL(_ bundleURL: URL) -> URL {
+        bundleURL.deletingPathExtension().appendingPathExtension("rpp")
+    }
+
+    // MARK: - Bake + write (background thread)
+
+    static func export(project: ProjectModel, clips: [Clip], bundleURL: URL,
+                       appending: Bool,
+                       progress: @escaping (Double) -> Void)
+        throws -> (SidecarPlan, [UUID: (path: String, cacheKey: String, duration: Double)], URL) {
+        let stemsDir = bundleURL.appendingPathComponent("Stems", isDirectory: true)
+        var plan = buildPlan(project: project, clips: clips,
+                             startNumber: nextStemNumber(in: stemsDir))
+        var adopted: [UUID: (path: String, cacheKey: String, duration: Double)] = [:]
+        var rpp: RppProject? = nil
+        if appending {
+            let rppURL = sidecarURL(bundleURL)
+            guard let loaded = RppProject.load(rppURL) else { throw ReaperError.sidecarUnreadable }
+            // Adoption: a clip whose item already lives in the file (v1-era
+            // export — item GUID == clip UUID) is married to that item and its
+            // existing stem instead of baked + appended again.
+            let existing = loaded.itemsByGUID()
+            let rppDir = rppURL.deletingLastPathComponent()
+            for i in plan.entries.indices {
+                let g = itemGUID(plan.entries[i].source.id)
+                guard let hit = existing[g] else { continue }
+                plan.entries[i].adoptGUID = g
+                let resolved: String
+                if let f = hit.item.sourceFile, !f.isEmpty {
+                    resolved = (f as NSString).isAbsolutePath ? f
+                        : rppDir.appendingPathComponent(f, isDirectory: false)
+                            .standardizedFileURL.path
+                } else {
+                    resolved = stemsDir.appendingPathComponent(plan.entries[i].stemFile,
+                                                               isDirectory: false).path
+                }
+                adopted[plan.entries[i].itemClipId] = (
+                    resolved,
+                    MediaPipeline.cacheKey(for: URL(fileURLWithPath: resolved, isDirectory: false)),
+                    plan.entries[i].source.sourceLength)
+            }
+            rpp = loaded
+        }
+        var (stems, rppURL) = try bakeAndWrite(project: project, plan: plan,
+                                               bundleURL: bundleURL,
+                                               existingRpp: rpp, progress: progress)
+        stems.merge(adopted) { fresh, _ in fresh }
+        return (plan, stems, rppURL)
+    }
+
+    private static func bakeAndWrite(project: ProjectModel, plan: SidecarPlan,
+                                     bundleURL: URL, existingRpp: RppProject?,
+                                     progress: @escaping (Double) -> Void)
+        throws -> ([UUID: (path: String, cacheKey: String, duration: Double)], URL) {
+        let stemsDir = bundleURL.appendingPathComponent("Stems", isDirectory: true)
+        try? FileManager.default.createDirectory(at: stemsDir, withIntermediateDirectories: true)
+        // The render destination the .rpp points at — exists up front so a
+        // render in REAPER can't fail on a missing folder.
+        try? FileManager.default.createDirectory(
+            at: bundleURL.appendingPathComponent("Render", isDirectory: true),
+            withIntermediateDirectories: true)
+
+        // Adopted entries already have items + stems in the file; only the
+        // fresh ones bake and append.
+        var freshPlan = plan
+        freshPlan.entries = plan.entries.filter { $0.adoptGUID == nil }
+        let stems = try bakeStems(project: project, plan: freshPlan,
+                                  stemsDir: stemsDir, progress: progress)
+
+        // The `.rpp` sits beside the `.sq` bundle; stems are referenced
+        // relative to it (`<Project>.sq/Stems/NN.wav`) so the pair is portable.
+        let rppURL = sidecarURL(bundleURL)
+        let rppDir = rppURL.deletingLastPathComponent()
+        let renderDirRel = relativePath(
+            of: bundleURL.appendingPathComponent("Render", isDirectory: true),
+            fromDirectory: rppDir)
+        let stemPath: (SidecarPlan.Entry) -> String = { entry in
+            relativePath(of: stemsDir.appendingPathComponent(entry.stemFile, isDirectory: false),
+                         fromDirectory: rppDir)
+        }
+
+        let text: String
+        if let rpp = existingRpp {
+            for entry in freshPlan.entries {
+                let item = itemBlock(reaperClip(for: entry, stemMediaId: nil, project: project),
+                                     stemPath: stemPath(entry), project: project)
+                guard let node = RppFile.parseFragment(item) else { continue }
+                let guid = plan.tracks[entry.reaperIndex].guid
+                if let track = rpp.track(guid: guid) {
+                    track.node.append(node)
+                } else {
+                    // Lane exists in the plan but not the file yet — add the track.
+                    let vi = entry.source.track.videoIndex ?? 0
+                    if let tnode = RppFile.parseFragment(
+                        trackBlock(name: plan.tracks[entry.reaperIndex].name,
+                                   guid: guid, hue: project.hue(for: .video(vi)),
+                                   items: "")) {
+                        rpp.root.insert(tnode, afterLast: "TRACK")
+                        tnode.append(node)
+                    }
+                }
+            }
+            if (rpp.root.string("RENDER_FILE") ?? "").isEmpty {
+                rpp.setRenderDestination(directory: renderDirRel, pattern: "mix")
+            }
+            text = rpp.serialize()
+        } else {
+            let itemClips = plan.entries.map { reaperClip(for: $0, stemMediaId: nil, project: project) }
+            var pathByItem: [UUID: String] = [:]
+            for entry in plan.entries { pathByItem[entry.itemClipId] = stemPath(entry) }
+            // The generator groups by SOURCE video track; give the item clips
+            // their source lanes back for grouping (ids/geometry stay).
+            var generatorClips: [Clip] = []
+            for (i, entry) in plan.entries.enumerated() {
+                var c = itemClips[i]
+                c.track = entry.source.track
+                generatorClips.append(c)
+            }
+            let raw = rppText(project: project, clips: generatorClips,
+                              stemPath: { pathByItem[$0.id] ?? "" },
+                              timestamp: Int(Date().timeIntervalSince1970))
+            guard let rpp = RppProject.parse(raw) else { throw ReaperError.sidecarUnreadable }
+            rpp.setRenderDestination(directory: renderDirRel, pattern: "mix")
+            text = rpp.serialize()
+        }
+
+        do { try text.write(to: rppURL, atomically: true, encoding: .utf8) }
+        catch { throw ReaperError.writeFailed(error.localizedDescription) }
+        DispatchQueue.main.async { progress(1) }
+        return (stems, rppURL)
+    }
+
+    /// 1 + the highest `NNN_` prefix already in `Stems/` — numbering continues
+    /// across appends so filenames never collide.
+    static func nextStemNumber(in stemsDir: URL) -> Int {
+        let names = (try? FileManager.default.contentsOfDirectory(atPath: stemsDir.path)) ?? []
+        let maxN = names.compactMap { Int($0.prefix(3)) }.max() ?? 0
+        return maxN + 1
+    }
+
+    // MARK: - Stem baking (ffmpeg)
+
+    /// Extract each entry's exact source range to a lossless 24-bit WAV.
+    /// Returns itemClipId → stem facts. Any unreadable source aborts the whole
+    /// export (a silently-dropped stem would desync the session).
+    static func bakeStems(project: ProjectModel, plan: SidecarPlan, stemsDir: URL,
+                          progress: @escaping (Double) -> Void)
+        throws -> [UUID: (path: String, cacheKey: String, duration: Double)] {
+        guard let ffmpeg = MediaPipeline.findExecutable("ffmpeg") else { throw ReaperError.noFfmpeg }
+
+        // Fail fast on any offline source rather than bake a partial session.
+        var missing: [String] = []
+        for entry in plan.entries {
+            guard let media = project.media(entry.source.mediaId) else { continue }
+            if MediaPipeline.shared.isOffline(media) { missing.append(media.displayName) }
+        }
+        if !missing.isEmpty { throw ReaperError.missingMedia(Array(Set(missing)).sorted()) }
+
+        var out: [UUID: (path: String, cacheKey: String, duration: Double)] = [:]
+        let n = max(1, plan.entries.count)
+        for (i, entry) in plan.entries.enumerated() {
+            let clip = entry.source
+            guard let media = project.media(clip.mediaId) else { continue }
+            let dest = stemsDir.appendingPathComponent(entry.stemFile, isDirectory: false)
+            let srcLen = max(0.001, clip.sourceLength)   // source seconds consumed
+            // Output seeking (-ss/-t AFTER -i) is sample-accurate — lipsync
+            // matters more than the extra decode time on an offline export.
+            let args = ["-y", "-i", media.path,
+                        "-ss", fmt(clip.srcIn), "-t", fmt(srcLen),
+                        "-map", "0:a:0", "-c:a", "pcm_s24le",
+                        "-progress", "pipe:1", "-nostats", dest.path]
+            let base = Double(i) / Double(n)
+            let span = 1.0 / Double(n)
+            // Reserve the last 2% of the bar for writing the .rpp.
+            let res = MediaPipeline.run(ffmpeg, args, duration: srcLen) { p in
+                DispatchQueue.main.async { progress(0.98 * (base + span * p)) }
+            }
+            guard res.exitCode == 0, FileManager.default.fileExists(atPath: dest.path) else {
+                throw ReaperError.bakeFailed("\(media.displayName)\n\(res.stdout.suffix(800))")
+            }
+            out[entry.itemClipId] = (dest.path, MediaPipeline.cacheKey(for: dest), srcLen)
+        }
+        return out
+    }
+
+    // MARK: - RPP text (pure, headless-testable)
+
+    /// Build a full `.rpp`. `clips` carry their SOURCE video lanes (one REAPER
+    /// track per lane); ids become item GUIDs. `timestamp` is the project's
+    /// creation unix time (0 in tests for determinism).
+    static func rppText(project: ProjectModel, clips: [Clip],
+                        stemPath: (Clip) -> String, timestamp: Int) -> String {
+        let byTrack = Dictionary(grouping: clips, by: { $0.track.videoIndex ?? 0 })
+        let trackIndices = byTrack.keys.sorted()
+
+        var tracks = ""
+        for ti in trackIndices {
+            let items = (byTrack[ti] ?? []).sorted { $0.start < $1.start }
+            var itemText = ""
+            for clip in items { itemText += itemBlock(clip, stemPath: stemPath(clip), project: project) }
+            tracks += trackBlock(name: "V\(ti + 1)", guid: trackGUID(ti),
+                                 hue: project.hue(for: .video(ti)), items: itemText)
+        }
+
+        // Ruler defaulting to time; TEMPO is inert because items are BEAT -1.
+        return """
+        <REAPER_PROJECT 0.1 "7.0/OSX64" \(timestamp)
+          RIPPLE 0
+          GROUPOVERRIDE 0 0 0
+          AUTOXFADE 1
+          TEMPO 120 4 4
+          SAMPLERATE 48000 0 0
+          LOOP 0
+          <RENDER_CFG
+          >
+        \(tracks)>
+
+        """
+    }
+
+    /// One `<TRACK>` chunk (2-space body indent, matching the generator's
+    /// nesting when embedded in `rppText`; `RppFile.parseFragment` doesn't care).
+    static func trackBlock(name: String, guid: String, hue: Double, items: String) -> String {
+        """
+          <TRACK \(guid)
+            NAME \(quoted(name))
+            PEAKCOL \(peakCol(hue: hue))
+            BEAT -1
+            VOLPAN 1 0 -1 -1 1
+            MUTESOLO 0 0 0
+            IPHASE 0
+            ISBUS 0 0
+            BUSCOMP 0 0
+            TRACKID \(guid)
+            NCHAN 2
+            MAINSEND 1 0
+        \(items)  >
+
+        """
+    }
+
+    /// One `<ITEM>` for a clip. All times in seconds; the stem is pre-trimmed
+    /// to the source range so `SOFFS 0` (a non-zero srcIn — e.g. a REAPER-side
+    /// slip that was pulled back in — round-trips through SOFFS).
+    static func itemBlock(_ clip: Clip, stemPath: String, project: ProjectModel) -> String {
+        let name = clip.reaperName ?? project.media(clip.mediaId)?.displayName ?? "clip"
+        let speed = clip.speed > 1e-6 ? clip.speed : 1
+        let gain = max(0, clip.gain)
+        let guid = clip.reaperGUID ?? itemGUID(clip.id)
+        // preserve-pitch off = match the sequencer's own playback (rate shifts
+        // pitch there); flip the 2nd PLAYRATE arg to 1 if that changes.
+        return """
+              <ITEM
+                POSITION \(fmt(clip.start))
+                SNAPOFFS 0
+                LENGTH \(fmt(clip.duration))
+                LOOP 0
+                ALLTAKES 0
+                FADEIN 1 \(fmt(clip.fadeIn)) 0 1 0 0
+                FADEOUT 1 \(fmt(clip.fadeOut)) 0 1 0 0
+                MUTE 0
+                SEL 0
+                IGUID \(guid)
+                IID 1
+                NAME \(quoted(name))
+                VOLPAN \(fmt(gain)) 0 1 -1
+                SOFFS \(fmt(max(0, clip.srcIn)))
+                PLAYRATE \(fmt(speed)) 0 0 -1 0 0.0025
+                CHANMODE 0
+                GUID \(guid)
+                <SOURCE WAVE
+                  FILE \(quoted(stemPath))
+                >
+              >
+
+        """
+    }
+
+    // MARK: - Helpers
+
+    /// Fixed-point, never scientific notation (which REAPER's parser rejects),
+    /// with trailing zeros trimmed for readability.
+    static func fmt(_ x: Double) -> String {
+        var s = String(format: "%.6f", x)
+        if s.contains(".") {
+            while s.hasSuffix("0") { s.removeLast() }
+            if s.hasSuffix(".") { s.removeLast() }
+        }
+        return s
+    }
+
+    /// Path of `target` relative to directory `base` (POSIX, `/`-joined, with
+    /// `..` hops if they diverge). Used so the `.rpp` references stems as
+    /// `<Project>.sq/Stems/NN.wav` rather than an absolute path.
+    static func relativePath(of target: URL, fromDirectory base: URL) -> String {
+        let t = target.standardizedFileURL.pathComponents
+        let b = base.standardizedFileURL.pathComponents
+        var i = 0
+        while i < t.count && i < b.count && t[i] == b[i] { i += 1 }
+        let comps = Array(repeating: "..", count: b.count - i) + t[i...]
+        return comps.joined(separator: "/")
+    }
+
+    static func itemGUID(_ id: UUID) -> String { "{\(id.uuidString)}" }
+
+    /// Deterministic, valid GUID shape from a source video-track index (stable
+    /// across exports — REAPER preserves it, so append finds its tracks again).
+    static func trackGUID(_ index: Int) -> String {
+        String(format: "{00000000-0000-0000-0000-%012X}", index + 1)
+    }
+
+    /// REAPER track colour is a native-endian BGR int with 0x1000000 set.
+    private static func peakCol(hue: Double) -> Int {
+        let c = NSColor(calibratedHue: CGFloat(hue), saturation: 0.55, brightness: 0.85, alpha: 1)
+        let r = Int((c.redComponent * 255).rounded())
+        let g = Int((c.greenComponent * 255).rounded())
+        let b = Int((c.blueComponent * 255).rounded())
+        return 0x1000000 | (b << 16) | (g << 8) | r
+    }
+
+    private static func sanitize(_ s: String) -> String {
+        let out = s.map { c -> Character in
+            (c.isLetter && c.isASCII) || (c.isNumber && c.isASCII) ? c : "_"
+        }
+        return out.isEmpty ? "clip" : String(out)
+    }
+
+    /// RPP strings aren't backslash-escaped — REAPER picks a delimiter the
+    /// string doesn't contain, trying `"`, then `'`, then a backtick.
+    static func quoted(_ s: String) -> String {
+        if !s.contains("\"") { return "\"\(s)\"" }
+        if !s.contains("'") { return "'\(s)'" }
+        if !s.contains("`") { return "`\(s)`" }
+        return "`\(s.replacingOccurrences(of: "`", with: "'"))`"
+    }
+}
+
+// MARK: - Headless end-to-end harness (`sequencer --reapertest <mediafile>`)
+
+/// Simulates the full sidecar lifecycle against real media, without a GUI:
+/// bake stems → write .rpp (with RENDER_*) → migrate the model → verify the
+/// reaper lanes → surgically move a clip and push → re-pull and diff.
+func runReaperTest(path: String) {
+    var pass = 0, fail = 0
+    func check(_ ok: Bool, _ label: String) {
+        print("\(ok ? "PASS" : "FAIL")  \(label)")
+        if ok { pass += 1 } else { fail += 1 }
+    }
+    let mediaURL = URL(fileURLWithPath: path)
+    guard FileManager.default.fileExists(atPath: path) else {
+        print("FAIL  no such media: \(path)"); exit(1)
+    }
+    var media = MediaItem(path: path)
+    media.duration = 3600; media.fps = 30; media.hasAudio = true
+
+    var project = ProjectModel()
+    project.fps = 30
+    project.media = [media]
+    project.tracks = [Track(hue: 0.1), Track(hue: 0.5)]
+    // v0: 3s at t=2, sped 2× with fades + boosted gain (consumes 6s of source).
+    var v0 = Clip(mediaId: media.id, track: .video(0), start: 2, srcIn: 5, duration: 3)
+    v0.speed = 2; v0.fadeIn = 0.5; v0.fadeOut = 0.5; v0.gain = 1.4
+    // v1: 4s at t=6 on a second track, straight.
+    let v1 = Clip(mediaId: media.id, track: .video(1), start: 6, srcIn: 20, duration: 4)
+    project.clips = [v0, v1]
+
+    let out = URL(fileURLWithPath: NSTemporaryDirectory())
+        .appendingPathComponent("reapertest", isDirectory: true)
+    try? FileManager.default.removeItem(at: out)
+    let bundle = out.appendingPathComponent("fake.sq", isDirectory: true)
+    let stemsDir = bundle.appendingPathComponent("Stems", isDirectory: true)
+    try? FileManager.default.createDirectory(at: stemsDir, withIntermediateDirectories: true)
+
+    print("== reapertest ==\nmedia: \(mediaURL.lastPathComponent)\nout:   \(out.path)")
+    do {
+        let clips = ReaperExport.exportClips(project)
+        check(clips.count == 2, "exportClips finds both clips")
+        let plan = ReaperExport.buildPlan(project: project, clips: clips,
+                                          startNumber: ReaperExport.nextStemNumber(in: stemsDir))
+        check(plan.tracks.count == 2 && plan.tracks[0].name == "V1", "plan: 2 reaper lanes")
+        check(plan.entries.allSatisfy { $0.isSplit },
+              "plan: video media → split entries")
+
+        let stems = try ReaperExport.bakeStems(project: project, plan: plan,
+                                               stemsDir: stemsDir, progress: { _ in })
+        for entry in plan.entries {
+            guard let stem = stems[entry.itemClipId] else { check(false, "stem baked"); continue }
+            let dur = probeDuration(stem.path)
+            let want = entry.source.sourceLength
+            check(abs(dur - want) < 0.15,
+                  "stem \((stem.path as NSString).lastPathComponent): \(String(format: "%.3f", dur))s (want ~\(String(format: "%.3f", want))s)")
+        }
+
+        // Full .rpp with render destination, as the app writes it.
+        let rppURL = out.appendingPathComponent("fake.rpp")
+        let itemClips = plan.entries.map { entry -> Clip in
+            var c = ReaperExport.reaperClip(for: entry, stemMediaId: nil, project: project)
+            c.track = entry.source.track
+            return c
+        }
+        var stemRel: [UUID: String] = [:]
+        for e in plan.entries { stemRel[e.itemClipId] = "fake.sq/Stems/\(e.stemFile)" }
+        let raw = ReaperExport.rppText(project: project, clips: itemClips,
+                                       stemPath: { stemRel[$0.id] ?? "" },
+                                       timestamp: Int(Date().timeIntervalSince1970))
+        guard let rpp = RppProject.parse(raw) else {
+            print("FAIL  generated rpp does not parse"); exit(1)
+        }
+        rpp.setRenderDestination(directory: "fake.sq/Render", pattern: "mix")
+        try rpp.serialize().write(to: rppURL, atomically: true, encoding: .utf8)
+        check(rpp.root.string("RENDER_FILE") == "fake.sq/Render", "RENDER_FILE points into bundle")
+
+        // Migration: clips leave the video lanes.
+        var migrated = project
+        ReaperExport.applyMigration(&migrated, plan: plan, stems: stems)
+        check(migrated.reaperTracks.count == 2, "migration adds reaper lanes")
+        check(migrated.clips.filter { $0.track.isReaper }.count == 2, "2 clips on reaper lanes")
+        check(migrated.clips.filter { $0.track.isReaper }.allSatisfy { $0.reaperGUID != nil },
+              "reaper clips carry item GUIDs")
+        check(migrated.clips.filter { !$0.track.isReaper }.allSatisfy(\.muted),
+              "video sources muted in place")
+        check(ReaperExport.exportClips(migrated).isEmpty,
+              "nothing left to export after migration")
+        check(migrated.laneRefs.prefix(2) == [.reaper(0), .reaper(1)],
+              "reaper lanes order above video lanes")
+
+        // Round-trip: pull-diff finds the items where the model put them.
+        let loaded = RppProject.load(rppURL)!
+        let byGUID = loaded.itemsByGUID()
+        for clip in migrated.clips where clip.track.isReaper {
+            let hit = byGUID[clip.reaperGUID ?? ""]
+            check(hit != nil && abs((hit?.item.position ?? -1) - clip.start) < 1e-6,
+                  "item \(clip.reaperName ?? "?") @ \(ReaperExport.fmt(clip.start)) matches model")
+        }
+
+        // Surgical push: move one clip +2.5s, write, re-load, verify.
+        if var moved = migrated.clips.first(where: { $0.track.isReaper }) {
+            moved.start += 2.5
+            let target = loaded.itemsByGUID()[moved.reaperGUID ?? ""]
+            target?.item.setPosition(moved.start)
+            try loaded.serialize().write(to: rppURL, atomically: true, encoding: .utf8)
+            let re = RppProject.load(rppURL)!
+            let pos = re.itemsByGUID()[moved.reaperGUID ?? ""]?.item.position ?? -1
+            check(abs(pos - moved.start) < 1e-6, "surgical push survives reload")
+        }
+
+        print("\nwrote \(rppURL.path)")
+        print("Open it:  open -a REAPER '\(rppURL.path)'")
+    } catch {
+        print("FAIL  \((error as? LocalizedError)?.errorDescription ?? "\(error)")")
+        exit(1)
+    }
+    print("\n\(fail == 0 ? "ALL PASS" : "\(fail) FAILURES") (\(pass) checks)")
+    exit(fail == 0 ? 0 : 1)
+}
+
+/// Headless sidecar exercise against a REAL `.sq` bundle
+/// (`sequencer --sidecartest <file.sq>`): runs the actual export path —
+/// including v1-item ADOPTION against the sibling `.rpp` — migrates the
+/// model, writes `project.json` back, and verifies the clip↔item join.
+func runSidecarTest(path: String) {
+    var pass = 0, fail = 0
+    func check(_ ok: Bool, _ label: String) {
+        print("\(ok ? "PASS" : "FAIL")  \(label)")
+        if ok { pass += 1 } else { fail += 1 }
+    }
+
+    let bundleURL = URL(fileURLWithPath: path, isDirectory: true)
+    let jsonURL = bundleURL.appendingPathComponent("project.json", isDirectory: false)
+    guard let data = try? Data(contentsOf: jsonURL),
+          let doc = try? JSONDecoder().decode(SequencerDocument.self, from: data) else {
+        print("FAIL  cannot read \(jsonURL.path)"); exit(1)
+    }
+    var project = doc.project
+    let rppURL = ReaperExport.sidecarURL(bundleURL)
+    let hadRpp = FileManager.default.fileExists(atPath: rppURL.path)
+    let itemsBefore = hadRpp ? (RppProject.load(rppURL)?.itemsByGUID().count ?? -1) : 0
+    print("== sidecartest ==\nbundle: \(bundleURL.lastPathComponent)   rpp: "
+          + (hadRpp ? "exists, \(itemsBefore) items" : "none"))
+
+    let clips = ReaperExport.exportClips(project)
+    guard !clips.isEmpty else { print("FAIL  nothing to export"); exit(1) }
+    do {
+        let (plan, stems, outURL) = try ReaperExport.export(
+            project: project, clips: clips, bundleURL: bundleURL,
+            appending: hadRpp, progress: { _ in })
+        let adopted = plan.entries.filter { $0.adoptGUID != nil }.count
+        print("entries: \(plan.entries.count) (\(adopted) adopted, \(plan.entries.count - adopted) fresh)")
+        check(stems.count == plan.entries.count, "every entry carries stem facts")
+
+        ReaperExport.applyMigration(&project, plan: plan, stems: stems)
+        check(project.hasReaper,
+              "model gained reaper lanes: \(project.reaperTracks.map(\.name))")
+        check(ReaperExport.exportClips(project).isEmpty, "nothing left to export")
+
+        guard let rpp = RppProject.load(outURL) else {
+            print("FAIL  written rpp unparseable"); exit(1)
+        }
+        let items = rpp.itemsByGUID()
+        if hadRpp {
+            check(items.count == itemsBefore + plan.entries.count - adopted,
+                  "no duplicate items (file has \(items.count))")
+        }
+        let rClips = project.clips.filter { $0.track.isReaper }
+        check(!rClips.isEmpty && rClips.allSatisfy { items[$0.reaperGUID ?? ""] != nil },
+              "every reaper clip joined to a file item (\(rClips.count) clips)")
+        check(!(rpp.root.string("RENDER_FILE") ?? "").isEmpty
+              && rpp.root.string("RENDER_PATTERN") == "mix",
+              "render destination set: \(rpp.root.string("RENDER_FILE") ?? "?")/mix.wav")
+        check(rClips.allSatisfy { c in
+            guard let m = project.media(c.mediaId) else { return c.reaperGhost }
+            return FileManager.default.fileExists(atPath: m.path)
+        }, "every reaper clip's stem resolves on disk")
+
+        let enc = JSONEncoder()
+        enc.outputFormatting = [.prettyPrinted, .sortedKeys]
+        let out = try enc.encode(SequencerDocument(project: project, view: doc.view))
+        try out.write(to: jsonURL, options: .atomic)
+        print("wrote migrated model → \(jsonURL.path)")
+    } catch {
+        print("FAIL  \((error as? LocalizedError)?.errorDescription ?? "\(error)")")
+        exit(1)
+    }
+    print("\n\(fail == 0 ? "ALL PASS" : "\(fail) FAILURES") (\(pass) checks)")
+    exit(fail == 0 ? 0 : 1)
+}
+
+/// ffprobe a media file's duration in seconds (0 on failure).
+private func probeDuration(_ path: String) -> Double {
+    guard let ffprobe = MediaPipeline.findExecutable("ffprobe") else { return 0 }
+    let res = MediaPipeline.run(ffprobe, ["-v", "error", "-show_entries", "format=duration",
+                                          "-of", "default=noprint_wrappers=1:nokey=1", path])
+    return Double(res.stdout.trimmingCharacters(in: .whitespacesAndNewlines)) ?? 0
+}
diff --git a/sequencer/Sources/Sequencer/ReaperLink.swift b/sequencer/Sources/Sequencer/ReaperLink.swift
new file mode 100644
index 0000000000000000000000000000000000000000..9a4668dcf0e418e111a8a26d6eab0ddbedc5d347
--- /dev/null
+++ b/sequencer/Sources/Sequencer/ReaperLink.swift
@@ -0,0 +1,275 @@
+import AppKit
+
+/// The live half of the REAPER sidecar: keeps the green reaper lanes and the
+/// sibling `.rpp` looking at the same truth.
+///
+/// Direction rules (the whole protocol):
+///  - **The `.rpp` is the source of truth for reaper lanes.** `pull` re-reads
+///    it whenever its mtime moves (document open, window/app focus) and
+///    reflects items into `.reaper` clips — matched by GUID, moved/retimed to
+///    the item's POSITION/LENGTH, foreign audio items imported as playable
+///    clips, anything else (MIDI…) as ghost clips. Pulls are NOT undoable
+///    (`Store.applyExternal`) — undoing external state would silently desync.
+///  - **The sequencer may edit reaper lanes only while REAPER is closed**
+///    (nothing can be mid-edit there). Moves mark `session.reaperDirty`;
+///    `push` flushes just the POSITIONs (and lane changes) back into the
+///    `.rpp` — a surgical rewrite through `RppFile`, everything REAPER wrote
+///    stays byte-identical — on window unfocus, REAPER launch, or before we
+///    open the project in REAPER ourselves.
+///
+/// There is no file watcher: like FusionComps, sync runs on focus edges
+/// (kqueue-style watchers are unreliable on network mounts, and focus is
+/// exactly when the answer can have changed — you were just in REAPER).
+enum ReaperLink {
+
+    static let reaperBundleId = "com.cockos.reaper"
+
+    /// Test hook: the uitest drives the gesture rules both ways, independent
+    /// of whether REAPER is actually running on the machine.
+    static var reaperRunningOverride: Bool?
+
+    static var reaperRunning: Bool {
+        if let o = reaperRunningOverride { return o }
+        return !NSRunningApplication.runningApplications(withBundleIdentifier: reaperBundleId).isEmpty
+    }
+
+    /// The sidecar path: `<Project>.rpp` next to the `.sq` bundle.
+    static func rppURL(_ ctx: DocumentContext) -> URL? {
+        ctx.document?.fileURL?.deletingPathExtension().appendingPathExtension("rpp")
+    }
+
+    /// Where the .rpp's RENDER_* points: the mixdown inside the bundle.
+    static func renderURL(_ ctx: DocumentContext) -> URL? {
+        ctx.document?.fileURL?
+            .appendingPathComponent("Render", isDirectory: true)
+            .appendingPathComponent("mix.wav", isDirectory: false)
+    }
+
+    // MARK: - Pull (.rpp → model)
+
+    /// Re-read the sidecar if it changed on disk and mirror it into the model.
+    /// Main-thread entry; file I/O and parsing run off-main, the model apply
+    /// hops back. Also refreshes the render-mixdown memo while it's near the
+    /// disk (playback reads that flag per tick and must never stat).
+    static func pull(_ ctx: DocumentContext, force: Bool = false) {
+        guard ctx.store.project.hasReaper,
+              let url = rppURL(ctx), let renderURL = renderURL(ctx) else { return }
+        let session = ctx.session
+        let lastSynced = session.reaperSyncedMtime
+        DispatchQueue.global(qos: .userInitiated).async {
+            let renderAttrs = try? FileManager.default.attributesOfItem(atPath: renderURL.path)
+            let renderReady = renderAttrs != nil
+            let renderMtime = renderAttrs?[.modificationDate] as? Date
+            DispatchQueue.main.async {
+                if session.reaperRenderReady != renderReady
+                    || session.reaperRenderMtime != renderMtime {
+                    session.reaperRenderReady = renderReady
+                    session.reaperRenderMtime = renderMtime
+                    NotificationCenter.default.post(name: .projectChanged, object: nil)
+                }
+            }
+            guard let attrs = try? FileManager.default.attributesOfItem(atPath: url.path),
+                  let mtime = attrs[.modificationDate] as? Date else { return }
+            guard force || mtime != lastSynced else { return }
+            guard let rpp = RppProject.load(url) else { return }   // torn write? next focus retries
+            let snapshot = takeSnapshot(rpp, rppDir: url.deletingLastPathComponent())
+            DispatchQueue.main.async {
+                apply(snapshot, to: ctx, mtime: mtime)
+            }
+        }
+    }
+
+    /// What a pull needs from the parsed file — plain values, safe to carry
+    /// across threads.
+    private struct ItemSnapshot {
+        var guid: String
+        var trackIndex: Int
+        var position: Double
+        var length: Double
+        var soffs: Double
+        var playrate: Double
+        var muted: Bool
+        var volume: Double
+        var fadeIn: Double
+        var fadeOut: Double
+        var name: String
+        var audioFile: String?   // resolved absolute path, when the source is an audio file
+    }
+    private struct RppSnapshot {
+        var tracks: [ReaperTrack]
+        var items: [ItemSnapshot]
+    }
+
+    private static func takeSnapshot(_ rpp: RppProject, rppDir: URL) -> RppSnapshot {
+        var tracks: [ReaperTrack] = []
+        var items: [ItemSnapshot] = []
+        for (ti, track) in rpp.tracks.enumerated() {
+            tracks.append(ReaperTrack(name: track.name, guid: track.guid))
+            for item in track.items where !item.guid.isEmpty {
+                var file: String?
+                if item.isAudioSource, let f = item.sourceFile, !f.isEmpty {
+                    let abs = (f as NSString).isAbsolutePath
+                        ? f
+                        : rppDir.appendingPathComponent(f, isDirectory: false)
+                            .standardizedFileURL.path
+                    if FileManager.default.fileExists(atPath: abs) { file = abs }
+                }
+                items.append(ItemSnapshot(
+                    guid: item.guid, trackIndex: ti,
+                    position: item.position, length: max(0.05, item.length),
+                    soffs: item.soffs,
+                    playrate: item.playrate > 1e-6 ? item.playrate : 1,
+                    muted: item.muted, volume: item.volume,
+                    fadeIn: item.fadeIn, fadeOut: item.fadeOut,
+                    name: item.name,
+                    audioFile: file))
+            }
+        }
+        return RppSnapshot(tracks: tracks, items: items)
+    }
+
+    /// Mirror a snapshot into the model (main thread). Known items retime
+    /// their clips; unknown audio items import (probed first, async); unknown
+    /// other items become ghosts; clips whose item vanished are removed.
+    private static func apply(_ snap: RppSnapshot, to ctx: DocumentContext, mtime: Date) {
+        // Probe any foreign audio files we haven't got media for yet, THEN
+        // apply everything in one external mutation.
+        let model = ctx.store.project
+        let knownPaths = Set(model.media.map(\.path))
+        let toProbe = Array(Set(
+            snap.items.compactMap(\.audioFile).filter { !knownPaths.contains($0) }))
+        var probed: [String: MediaItem] = [:]
+        let group = DispatchGroup()
+        for path in toProbe {
+            group.enter()
+            MediaPipeline.shared.importFile(URL(fileURLWithPath: path, isDirectory: false)) { item in
+                if let item { probed[path] = item }
+                group.leave()
+            }
+        }
+        group.notify(queue: .main) {
+            ctx.store.applyExternal { model in
+                model.reaperTracks = snap.tracks
+                for (path, item) in probed where !model.media.contains(where: { $0.path == path }) {
+                    model.media.append(item)
+                }
+                var clipIndexByGUID: [String: Int] = [:]
+                for (i, clip) in model.clips.enumerated() {
+                    if let g = clip.reaperGUID { clipIndexByGUID[g] = i }
+                }
+                var seen = Set<String>()
+                for item in snap.items {
+                    seen.insert(item.guid)
+                    if let i = clipIndexByGUID[item.guid] {
+                        var c = model.clips[i]
+                        c.track = .reaper(item.trackIndex)
+                        c.start = item.position
+                        c.duration = item.length
+                        c.speed = item.playrate
+                        c.muted = item.muted
+                        c.gain = item.volume
+                        c.fadeIn = item.fadeIn
+                        c.fadeOut = item.fadeOut
+                        if !c.reaperGhost { c.srcIn = item.soffs }
+                        if !item.name.isEmpty { c.reaperName = item.name }
+                        model.clips[i] = c
+                    } else {
+                        // New item authored in REAPER — bring it in.
+                        let mediaId = item.audioFile.flatMap { path in
+                            model.media.first { $0.path == path }?.id
+                        }
+                        var c = Clip(mediaId: mediaId, track: .reaper(item.trackIndex),
+                                     start: item.position, srcIn: item.soffs,
+                                     duration: item.length, kind: .audio)
+                        c.speed = item.playrate
+                        c.muted = item.muted
+                        c.gain = item.volume
+                        c.fadeIn = item.fadeIn
+                        c.fadeOut = item.fadeOut
+                        c.reaperGUID = item.guid
+                        c.reaperGhost = (mediaId == nil)
+                        c.reaperName = item.name.isEmpty ? nil : item.name
+                        model.clips.append(c)
+                    }
+                }
+                // Items deleted in REAPER take their clips with them.
+                model.clips.removeAll { clip in
+                    guard let g = clip.reaperGUID, clip.track.isReaper else { return false }
+                    return !seen.contains(g)
+                }
+            }
+            ctx.session.reaperSyncedMtime = mtime
+            ctx.session.reaperDirty = false
+        }
+    }
+
+    // MARK: - Push (model → .rpp)
+
+    /// Flush sequencer-side reaper-lane moves into the `.rpp` — only when
+    /// something is dirty and REAPER is closed. POSITION and track membership
+    /// only: that's the entire edit surface the sequencer allows on these
+    /// lanes. `completion` fires on main after the write (or immediately when
+    /// there is nothing to do).
+    static func push(_ ctx: DocumentContext, completion: (() -> Void)? = nil) {
+        let session = ctx.session
+        guard session.reaperDirty, !reaperRunning,
+              ctx.store.project.hasReaper, let url = rppURL(ctx) else {
+            completion?(); return
+        }
+        let model = ctx.store.project
+        // (guid, start, muted, target track GUID) per reaper clip — plain
+        // values, safe to carry off-main.
+        let moves: [(String, Double, Bool, String)] = model.clips.compactMap { clip in
+            guard clip.track.isReaper, let g = clip.reaperGUID,
+                  let ri = clip.track.reaperIndex,
+                  model.reaperTracks.indices.contains(ri) else { return nil }
+            return (g, clip.start, clip.muted, model.reaperTracks[ri].guid)
+        }
+        DispatchQueue.global(qos: .userInitiated).async {
+            guard let rpp = RppProject.load(url) else {
+                DispatchQueue.main.async { completion?() }
+                return
+            }
+            let byGUID = rpp.itemsByGUID()
+            let tracks = rpp.tracks
+            for (guid, start, muted, trackGUID) in moves {
+                guard let (ti, item) = byGUID[guid] else { continue }
+                item.setPosition(start)
+                item.setMuted(muted)
+                if tracks.indices.contains(ti), tracks[ti].guid != trackGUID,
+                   let target = rpp.track(guid: trackGUID) {
+                    rpp.move(item: item, to: target)
+                }
+            }
+            do { try rpp.serialize().write(to: url, atomically: true, encoding: .utf8) }
+            catch {
+                DispatchQueue.main.async { completion?() }
+                return
+            }
+            let attrs = try? FileManager.default.attributesOfItem(atPath: url.path)
+            let mtime = attrs?[.modificationDate] as? Date
+            DispatchQueue.main.async {
+                session.reaperDirty = false
+                if let mtime { session.reaperSyncedMtime = mtime }
+                completion?()
+            }
+        }
+    }
+
+    // MARK: - Open in REAPER
+
+    /// Flush pending sequencer-side moves, then hand the project to REAPER.
+    static func openInReaper(_ ctx: DocumentContext) {
+        guard let url = rppURL(ctx),
+              FileManager.default.fileExists(atPath: url.path) else {
+            NotificationCenter.default.post(name: .transientStatus, object: nil,
+                userInfo: ["text": "No REAPER project yet — File ▸ Export Selection to REAPER first"])
+            return
+        }
+        push(ctx) {
+            NotificationCenter.default.post(name: .transientStatus, object: nil,
+                userInfo: ["text": "Opening \(url.lastPathComponent) in REAPER…"])
+            NSWorkspace.shared.open(url)
+        }
+    }
+}
diff --git a/sequencer/Sources/Sequencer/RppFile.swift b/sequencer/Sources/Sequencer/RppFile.swift
new file mode 100644
index 0000000000000000000000000000000000000000..82e9ae30fcd0d42ea1716b8fff2bf53a152bc09f
--- /dev/null
+++ b/sequencer/Sources/Sequencer/RppFile.swift
@@ -0,0 +1,470 @@
+import Foundation
+
+/// A parsed REAPER `.rpp` project — a lossless chunk tree.
+///
+/// REAPER's format is line-based and hierarchical: a chunk opens with
+/// `<NAME rest…`, contains value lines and child chunks, and closes with a
+/// lone `>` at the opener's indent. The parser keeps every line it doesn't
+/// understand verbatim (trimmed; indentation is deterministic — two spaces per
+/// depth — and regenerated on serialize), so parse→serialize reproduces a
+/// REAPER-saved file byte-for-byte and surgical edits (move an item, set a
+/// render path) can't destroy state REAPER cares about. `--rpptest` asserts
+/// the round-trip against a real REAPER save.
+///
+/// Strings use REAPER's delimiter-selection quoting (see `ReaperExport.quoted`),
+/// never backslash escapes.
+final class RppNode {
+    enum Child {
+        case line(String)      // trimmed content, verbatim otherwise
+        case node(RppNode)
+    }
+
+    var name: String           // first token after '<'
+    var headerRest: String     // remainder of the opener line, verbatim ("" if none)
+    var children: [Child] = []
+    /// Line terminator of the parsed file (root node only). REAPER writes
+    /// CRLF even on macOS; our own generator writes LF — serialize with
+    /// whichever the file came with so round-trips stay byte-identical.
+    var eol: String = "\n"
+
+    init(name: String, headerRest: String = "") {
+        self.name = name
+        self.headerRest = headerRest
+    }
+
+    // MARK: Value-line access
+
+    /// First line whose first token is `key` → its argument string (raw, unsplit).
+    func rawValue(_ key: String) -> String? {
+        for child in children {
+            if case .line(let l) = child, let rest = RppFile.match(l, key: key) { return rest }
+        }
+        return nil
+    }
+
+    /// Tokenized args of the `key` line (quotes stripped).
+    func args(_ key: String) -> [String]? {
+        rawValue(key).map(RppFile.tokenize)
+    }
+
+    func double(_ key: String) -> Double? {
+        guard let a = args(key), let f = a.first else { return nil }
+        return Double(f)
+    }
+
+    func string(_ key: String) -> String? { args(key)?.first }
+
+    /// Replace the `key` line's arguments (or insert the line if absent —
+    /// before the first child chunk, i.e. into the property section).
+    func setValue(_ key: String, _ argText: String) {
+        let line = argText.isEmpty ? key : "\(key) \(argText)"
+        for (i, child) in children.enumerated() {
+            if case .line(let l) = child, RppFile.match(l, key: key) != nil {
+                children[i] = .line(line); return
+            }
+        }
+        let at = children.firstIndex { if case .node = $0 { return true }; return false } ?? children.count
+        children.insert(.line(line), at: at)
+    }
+
+    // MARK: Child-chunk access
+
+    func nodes(_ name: String) -> [RppNode] {
+        children.compactMap { if case .node(let n) = $0, n.name == name { return n }; return nil }
+    }
+
+    func firstNode(_ name: String) -> RppNode? { nodes(name).first }
+
+    func append(_ node: RppNode) { children.append(.node(node)) }
+
+    func remove(_ node: RppNode) {
+        children.removeAll { if case .node(let n) = $0 { return n === node }; return false }
+    }
+
+    /// Insert `node` after the last existing child chunk named `name`
+    /// (or at the end when there is none).
+    func insert(_ node: RppNode, afterLast name: String) {
+        var at = children.count
+        for (i, child) in children.enumerated() {
+            if case .node(let n) = child, n.name == name { at = i + 1 }
+        }
+        children.insert(.node(node), at: at)
+    }
+}
+
+enum RppFile {
+
+    // MARK: - Parse
+
+    static func parse(_ text: String) -> RppNode? {
+        var root: RppNode?
+        var stack: [RppNode] = []
+        // "\r\n" is ONE Character in Swift, so split(separator: "\n") would
+        // not split a CRLF file (REAPER writes CRLF, even on macOS) — normalize
+        // first, remember the terminator for serialize.
+        let eol = text.contains("\r\n") ? "\r\n" : "\n"
+        let normalized = eol == "\r\n" ? text.replacingOccurrences(of: "\r\n", with: "\n") : text
+        for rawLine in normalized.split(separator: "\n", omittingEmptySubsequences: false) {
+            let line = rawLine.trimmingCharacters(in: .whitespaces)
+            if line.hasPrefix("<") {
+                let body = String(line.dropFirst())
+                let (name, rest) = splitFirstToken(body)
+                let node = RppNode(name: name, headerRest: rest)
+                if let top = stack.last { top.append(node) }
+                else if root == nil { root = node }
+                else { return nil }               // second top-level chunk — not an .rpp
+                stack.append(node)
+            } else if line == ">" {
+                guard !stack.isEmpty else { return nil }
+                stack.removeLast()
+            } else {
+                guard let top = stack.last else {
+                    if line.isEmpty { continue }   // stray blank outside chunks
+                    return nil
+                }
+                top.children.append(.line(line))
+            }
+        }
+        // A well-formed file closes every chunk; a truncated one must not
+        // round-trip as if intact (REAPER mid-write, torn copy).
+        guard stack.isEmpty, let r = root, r.name == "REAPER_PROJECT" else { return nil }
+        r.eol = eol
+        return r
+    }
+
+    /// Parse a standalone chunk fragment (e.g. a generated `<ITEM … >` block).
+    static func parseFragment(_ text: String) -> RppNode? {
+        var stack: [RppNode] = []
+        var root: RppNode?
+        for rawLine in text.split(separator: "\n", omittingEmptySubsequences: false) {
+            let line = rawLine.trimmingCharacters(in: .whitespaces)
+            if line.isEmpty { continue }
+            if line.hasPrefix("<") {
+                let (name, rest) = splitFirstToken(String(line.dropFirst()))
+                let node = RppNode(name: name, headerRest: rest)
+                if let top = stack.last { top.append(node) } else { root = node }
+                stack.append(node)
+            } else if line == ">" {
+                guard !stack.isEmpty else { return nil }
+                stack.removeLast()
+            } else {
+                guard let top = stack.last else { return nil }
+                top.children.append(.line(line))
+            }
+        }
+        return stack.isEmpty ? root : nil
+    }
+
+    // MARK: - Serialize
+
+    static func serialize(_ root: RppNode) -> String {
+        var out = ""
+        write(root, depth: 0, eol: root.eol, into: &out)
+        return out
+    }
+
+    private static func write(_ node: RppNode, depth: Int, eol: String, into out: inout String) {
+        let pad = String(repeating: "  ", count: depth)
+        out += pad + "<" + node.name + (node.headerRest.isEmpty ? "" : " " + node.headerRest) + eol
+        let childPad = String(repeating: "  ", count: depth + 1)
+        for child in node.children {
+            switch child {
+            case .line(let l):
+                out += l.isEmpty ? eol : childPad + l + eol
+            case .node(let n):
+                write(n, depth: depth + 1, eol: eol, into: &out)
+            }
+        }
+        out += pad + ">" + eol
+    }
+
+    // MARK: - Line helpers
+
+    /// If `line`'s first token is `key`, return the remainder (may be "").
+    static func match(_ line: String, key: String) -> String? {
+        guard line.hasPrefix(key) else { return nil }
+        let rest = line.dropFirst(key.count)
+        if rest.isEmpty { return "" }
+        guard rest.first == " " else { return nil }   // KEY2 must not match KEY
+        return String(rest.dropFirst())
+    }
+
+    /// Split REAPER-style args: whitespace-separated tokens, strings quoted
+    /// with `"`, `'`, or a backtick (no escapes — the delimiter simply doesn't
+    /// occur inside). Quotes are stripped from the returned tokens.
+    static func tokenize(_ s: String) -> [String] {
+        var out: [String] = []
+        var i = s.startIndex
+        while i < s.endIndex {
+            let c = s[i]
+            if c == " " || c == "\t" { i = s.index(after: i); continue }
+            if c == "\"" || c == "'" || c == "`" {
+                var j = s.index(after: i)
+                var tok = ""
+                while j < s.endIndex && s[j] != c { tok.append(s[j]); j = s.index(after: j) }
+                out.append(tok)
+                i = j < s.endIndex ? s.index(after: j) : j
+            } else {
+                var j = i
+                var tok = ""
+                while j < s.endIndex && s[j] != " " && s[j] != "\t" { tok.append(s[j]); j = s.index(after: j) }
+                out.append(tok)
+                i = j
+            }
+        }
+        return out
+    }
+
+    static func splitFirstToken(_ s: String) -> (String, String) {
+        if let sp = s.firstIndex(of: " ") {
+            return (String(s[..<sp]), String(s[s.index(after: sp)...]))
+        }
+        return (s, "")
+    }
+}
+
+// MARK: - Typed views over the tree
+
+/// A `<TRACK {guid} … >` chunk.
+struct RppTrack {
+    let node: RppNode
+
+    /// The GUID in the chunk header (REAPER always writes one).
+    var guid: String { RppFile.tokenize(node.headerRest).first ?? "" }
+    var name: String { node.string("NAME") ?? "" }
+    var items: [RppItem] { node.nodes("ITEM").map(RppItem.init) }
+}
+
+/// An `<ITEM … >` chunk.
+struct RppItem {
+    let node: RppNode
+
+    var guid: String { node.string("GUID") ?? node.string("IGUID") ?? "" }
+    var position: Double { node.double("POSITION") ?? 0 }
+    var length: Double { node.double("LENGTH") ?? 0 }
+    var soffs: Double { node.double("SOFFS") ?? 0 }
+    var playrate: Double { node.double("PLAYRATE") ?? 1 }
+    var name: String { node.string("NAME") ?? "" }
+    var muted: Bool { (node.double("MUTE") ?? 0) != 0 }
+    var volume: Double { node.double("VOLPAN") ?? 1 }
+
+    /// Fade length is arg 2 of FADEIN/FADEOUT.
+    var fadeIn: Double { (node.args("FADEIN")?.dropFirst().first).flatMap(Double.init) ?? 0 }
+    var fadeOut: Double { (node.args("FADEOUT")?.dropFirst().first).flatMap(Double.init) ?? 0 }
+
+    /// The `<SOURCE TYPE … >` chunk, descending through one SECTION wrapper.
+    var source: RppNode? {
+        guard let s = node.firstNode("SOURCE") else { return nil }
+        if RppFile.splitFirstToken(s.headerRest).0 == "SECTION", let inner = s.firstNode("SOURCE") {
+            return inner
+        }
+        return s
+    }
+
+    var sourceType: String { source.map { RppFile.splitFirstToken($0.headerRest).0 } ?? "" }
+    var sourceFile: String? { source?.string("FILE") }
+
+    /// Audio-file-backed source (something the sequencer can play directly).
+    /// Everything else — MIDI, click, empty, video processors — is a ghost.
+    var isAudioSource: Bool {
+        ["WAVE", "FLAC", "MP3", "OGG", "VORBIS", "OPUS", "WAVPACK"].contains(sourceType)
+    }
+
+    func setPosition(_ t: Double) { node.setValue("POSITION", ReaperExport.fmt(t)) }
+
+    /// Preserve any extra MUTE args (REAPER 7 writes two).
+    func setMuted(_ m: Bool) {
+        var a = node.args("MUTE") ?? ["0", "0"]
+        if a.isEmpty { a = ["0"] }
+        a[0] = m ? "1" : "0"
+        node.setValue("MUTE", a.joined(separator: " "))
+    }
+}
+
+/// The parsed project: typed access + the surgical edits the sidecar needs.
+struct RppProject {
+    let root: RppNode
+
+    static func parse(_ text: String) -> RppProject? {
+        RppFile.parse(text).map(RppProject.init)
+    }
+
+    static func load(_ url: URL) -> RppProject? {
+        guard let text = try? String(contentsOf: url, encoding: .utf8) else { return nil }
+        return parse(text)
+    }
+
+    func serialize() -> String { RppFile.serialize(root) }
+
+    var tracks: [RppTrack] { root.nodes("TRACK").map(RppTrack.init) }
+
+    func track(guid: String) -> RppTrack? { tracks.first { $0.guid == guid } }
+
+    /// item GUID → (track array index, item) across the whole project.
+    func itemsByGUID() -> [String: (trackIndex: Int, item: RppItem)] {
+        var out: [String: (Int, RppItem)] = [:]
+        for (ti, track) in tracks.enumerated() {
+            for item in track.items where !item.guid.isEmpty {
+                out[item.guid] = (ti, item)
+            }
+        }
+        return out
+    }
+
+    /// Move an item chunk to another track (append at its end — REAPER does
+    /// not require items sorted).
+    func move(item: RppItem, to track: RppTrack) {
+        for t in tracks where t.node.nodes("ITEM").contains(where: { $0 === item.node }) {
+            t.node.remove(item.node)
+        }
+        track.node.append(item.node)
+    }
+
+    /// Point the project's render output at `directory`/`pattern`.wav
+    /// (24-bit WAV, entire project). Directory may be relative to the .rpp.
+    func setRenderDestination(directory: String, pattern: String) {
+        root.setValue("RENDER_FILE", ReaperExport.quoted(directory))
+        root.setValue("RENDER_PATTERN", ReaperExport.quoted(pattern))
+        root.setValue("RENDER_FMT", "0 2 0")
+        root.setValue("RENDER_RANGE", "1 0 0 0 1000")   // 1 = entire project
+        root.setValue("RENDER_STEMS", "0")              // master mix
+        root.setValue("RENDER_ADDTOPROJ", "0")
+        let cfg = root.firstNode("RENDER_CFG") ?? {
+            let n = RppNode(name: "RENDER_CFG")
+            root.append(n)
+            return n
+        }()
+        cfg.children = [.line("ZXZhdxgAAA==")]           // 'evaw' + 24-bit: WAV
+    }
+}
+
+// MARK: - Headless harness (`sequencer --rpptest <file.rpp>`)
+
+/// Round-trips a real (ideally REAPER-saved) `.rpp` byte-for-byte, then
+/// exercises the surgical edits the sidecar relies on. Never writes to disk.
+func runRppTest(path: String) {
+    var pass = 0, fail = 0
+    func check(_ ok: Bool, _ label: String) {
+        print("\(ok ? "PASS" : "FAIL")  \(label)")
+        if ok { pass += 1 } else { fail += 1 }
+    }
+
+    guard let text = try? String(contentsOfFile: path, encoding: .utf8) else {
+        print("FAIL  cannot read \(path)"); exit(1)
+    }
+    guard let proj = RppProject.parse(text) else {
+        print("FAIL  parse returned nil"); exit(1)
+    }
+
+    // 1. Lossless round-trip.
+    let out = proj.serialize()
+    if out == text {
+        check(true, "round-trip byte-identical (\(text.count) bytes)")
+    } else {
+        check(false, "round-trip byte-identical")
+        let a = text.split(separator: "\n", omittingEmptySubsequences: false)
+        let b = out.split(separator: "\n", omittingEmptySubsequences: false)
+        for i in 0..<max(a.count, b.count) {
+            let l = i < a.count ? String(a[i]) : "<EOF>"
+            let r = i < b.count ? String(b[i]) : "<EOF>"
+            if l != r {
+                print("  first diff at line \(i + 1):\n    file: \(l)\n    ours: \(r)")
+                break
+            }
+        }
+    }
+
+    // 2. Census.
+    let tracks = proj.tracks
+    let itemCount = tracks.reduce(0) { $0 + $1.items.count }
+    check(!tracks.isEmpty, "parsed \(tracks.count) tracks, \(itemCount) items")
+    for t in tracks {
+        let items = t.items.map { "\($0.name)@\(ReaperExport.fmt($0.position))" }.joined(separator: ", ")
+        print("      \(t.name.isEmpty ? t.guid : t.name): \(items.isEmpty ? "(empty)" : items)")
+    }
+
+    // 3. Position surgery: exactly one line differs afterwards.
+    if let first = tracks.first?.items.first {
+        let was = first.position
+        first.setPosition(was + 1.5)
+        let mutated = proj.serialize()
+        let reparsed = RppProject.parse(mutated)
+        let again = reparsed?.tracks.first?.items.first
+        check(abs((again?.position ?? -1) - (was + 1.5)) < 1e-9, "setPosition survives reserialize")
+        let a = text.split(separator: "\n", omittingEmptySubsequences: false)
+        let b = mutated.split(separator: "\n", omittingEmptySubsequences: false)
+        let diffs = zip(a, b).filter { $0 != $1 }.count + abs(a.count - b.count)
+        check(diffs == 1, "surgery touched exactly one line (\(diffs))")
+        first.setPosition(was)   // restore for later checks
+    }
+
+    // 4. GUID index + fragment append.
+    let byGUID = proj.itemsByGUID()
+    check(byGUID.count == itemCount, "itemsByGUID covers all items (\(byGUID.count))")
+    let fragment = """
+    <ITEM
+      POSITION 42
+      LENGTH 2
+      GUID {AAAAAAAA-0000-0000-0000-000000000042}
+      NAME "appended"
+      <SOURCE WAVE
+        FILE "Stems/zz.wav"
+      >
+    >
+    """
+    if let node = RppFile.parseFragment(fragment), let t0 = tracks.first {
+        t0.node.append(node)
+        let re = RppProject.parse(proj.serialize())
+        let found = re?.itemsByGUID()["{AAAAAAAA-0000-0000-0000-000000000042}"]
+        check(found != nil && abs((found?.item.position ?? 0) - 42) < 1e-9, "fragment append lands")
+        t0.node.remove(node)
+    } else {
+        check(false, "fragment append lands")
+    }
+
+    // 5. MIDI item classifies as ghost; SECTION unwraps.
+    let midi = RppFile.parseFragment("""
+    <ITEM
+      POSITION 1
+      LENGTH 4
+      GUID {BBBBBBBB-0000-0000-0000-000000000001}
+      <SOURCE MIDI
+        HASDATA 1 960 QN
+        E 0 90 3c 60
+      >
+    >
+    """).map(RppItem.init)
+    check(midi?.sourceType == "MIDI" && midi?.isAudioSource == false, "MIDI item → ghost")
+    let section = RppFile.parseFragment("""
+    <ITEM
+      POSITION 0
+      <SOURCE SECTION
+        LENGTH 3
+        <SOURCE WAVE
+          FILE "x.wav"
+        >
+      >
+    >
+    """).map(RppItem.init)
+    check(section?.sourceType == "WAVE" && section?.sourceFile == "x.wav", "SECTION source unwraps")
+
+    // 6. Cross-track move.
+    if tracks.count >= 2, let item = tracks[0].items.first {
+        let guid = item.guid
+        proj.move(item: item, to: tracks[1])
+        let re = RppProject.parse(proj.serialize())
+        check(re?.itemsByGUID()[guid]?.trackIndex == 1, "move item across tracks")
+        proj.move(item: item, to: tracks[0])
+    }
+
+    // 7. Render destination.
+    proj.setRenderDestination(directory: "owo.sq/Render", pattern: "mix")
+    let re = RppProject.parse(proj.serialize())
+    check(re?.root.string("RENDER_FILE") == "owo.sq/Render"
+          && re?.root.string("RENDER_PATTERN") == "mix"
+          && re?.root.firstNode("RENDER_CFG")?.children.count == 1,
+          "setRenderDestination writes FILE/PATTERN/CFG")
+
+    print("\n\(fail == 0 ? "ALL PASS" : "\(fail) FAILURES") (\(pass) checks)")
+    exit(fail == 0 ? 0 : 1)
+}
diff --git a/sequencer/Sources/Sequencer/SessionState.swift b/sequencer/Sources/Sequencer/SessionState.swift
index e7077fe778fa300cfe7b7df20a07d95831d6151e..5f62838b9c213360abf670b20e4422dea31731a9 100644
--- a/sequencer/Sources/Sequencer/SessionState.swift
+++ b/sequencer/Sources/Sequencer/SessionState.swift
@@ -36,6 +36,24 @@ final class SessionState {
     /// The Fusion comps band gets its own hide/focus.
     var fusionHidden = false { didSet { postViewOptions() } }
     var fusionFocus = false { didSet { postViewOptions() } }
+
+    /// The REAPER sidecar band collapsed to slivers (toggled by the single
+    /// button on its merged header). Portable via ViewState.
+    var reaperCollapsed = false { didSet { postViewOptions() } }
+
+    // REAPER sidecar session state (not persisted — the .rpp is the truth):
+    /// Reaper-lane clips were moved here and the .rpp doesn't know yet.
+    /// Flushed by `ReaperLink.push` on window unfocus / REAPER launch.
+    var reaperDirty = false
+    /// mtime of the .rpp at the last successful pull/push — pull re-runs only
+    /// when the file has moved past this (and never re-imports our own write).
+    var reaperSyncedMtime: Date?
+    /// Memoized existence + mtime of the rendered mixdown (`Render/mix.wav`
+    /// in the bundle), refreshed off-main by `ReaperLink.pull` on focus —
+    /// playback reads these per tick, and per-tick disk stats are banned. The
+    /// mtime lets the mixdown player reload after a re-render.
+    var reaperRenderReady = false
+    var reaperRenderMtime: Date?
     /// The one pane (a lane, or `.fusion`) blown up large while the rest tile in
     /// the leftover space — "Priority" mode, à la Google Meet's spotlight.
     var priorityPane: TrackRef? = nil { didSet { postViewOptions() } }
@@ -50,9 +68,8 @@ final class SessionState {
 
     /// Is there a storyboard panel under the playhead to draw on?
     var panelUnderPlayhead: Clip? {
-        let p = ctx.store.project
-        let t = ctx.playback.playhead
-        return p.clipAt(track: .storyboard, time: t, kind: .storyboard)
+        ctx.store.index.clipAt(track: .storyboard, time: ctx.playback.playhead,
+                               kind: .storyboard)
     }
 
     // MARK: - Track visibility
@@ -115,6 +132,7 @@ final class SessionState {
         v.priorityPane = priorityPane
         v.fusionHidden = fusionHidden
         v.fusionFocus = fusionFocus
+        v.reaperCollapsed = reaperCollapsed
         v.playhead = ctx.playback.playhead
         return v
     }
@@ -133,6 +151,7 @@ final class SessionState {
         priorityPane = v.priorityPane
         fusionHidden = v.fusionHidden
         fusionFocus = v.fusionFocus
+        reaperCollapsed = v.reaperCollapsed
         if v.playhead > 0 { ctx.playback.seek(to: v.playhead) }
     }
 
diff --git a/sequencer/Sources/Sequencer/Store.swift b/sequencer/Sources/Sequencer/Store.swift
index 2f5f8e4ea8ca535d09b311d710d59c47ce96cbfe..6ccb85c5ef89b742afc47e9e6f4a6216b9d82e3b 100644
--- a/sequencer/Sources/Sequencer/Store.swift
+++ b/sequencer/Sources/Sequencer/Store.swift
@@ -21,7 +21,22 @@ final class Store {
     /// The document context that owns this store. Set at construction.
     unowned var ctx: DocumentContext!
 
-    private(set) var project = ProjectModel()
+    private(set) var project = ProjectModel() {
+        didSet { indexCache = nil }
+    }
+
+    /// Derived lookup index over the current model (see `ClipIndex`). Rebuilt
+    /// lazily after any mutation; the 60 Hz paths (player sync, viewer cells,
+    /// transport, subtitles) MUST query through this instead of the model's
+    /// O(clips) filter passes.
+    private var indexCache: ClipIndex?
+    var index: ClipIndex {
+        if let i = indexCache { return i }
+        let i = ClipIndex(project)
+        indexCache = i
+        return i
+    }
+
     var selection: Set<UUID> = [] {
         didSet { if selection != oldValue { post(.selectionChanged) } }
     }
@@ -186,6 +201,22 @@ final class Store {
         post(.projectChanged)
     }
 
+    /// External-state reflection (the REAPER sidecar pull): mutate the model
+    /// WITHOUT an undo entry. The change originated outside the app — undoing
+    /// it here would silently desync the timeline from the `.rpp` on disk, so
+    /// it must not sit on the undo timeline. Skipped during a live gesture
+    /// (the pull re-fires on the next focus change).
+    func applyExternal(_ body: (inout ProjectModel) -> Void) {
+        guard gestureBase == nil else { return }
+        var copy = project
+        body(&copy)
+        copy.normalizeStoryboards()
+        guard copy != project else { return }
+        project = copy
+        pruneSelection()
+        changed()
+    }
+
     func undo() {
         if gestureBase != nil { cancelGesture(); return }
         guard let entry = undoStack.popLast() else { return }
diff --git a/sequencer/Sources/Sequencer/Theme.swift b/sequencer/Sources/Sequencer/Theme.swift
index 97888fb757b13f7ca09227387c73abf9afb2a2c4..8aefbb6b8d33bc4b4cba0ee5bcfd09367ae25733 100644
--- a/sequencer/Sources/Sequencer/Theme.swift
+++ b/sequencer/Sources/Sequencer/Theme.swift
@@ -46,6 +46,23 @@ enum Theme {
         pick(NSColor(calibratedHue: 0.60, saturation: 0.28, brightness: 0.20, alpha: 1),
              NSColor(calibratedHue: 0.60, saturation: 0.14, brightness: 0.78, alpha: 1))
     }
+    /// The REAPER sidecar green — hardcoded #06FD99, the color of every clip on
+    /// a reaper lane (and the accent for anything reaper-linked).
+    static let reaperGreen = NSColor(calibratedRed: 0x06 / 255.0, green: 0xFD / 255.0,
+                                     blue: 0x99 / 255.0, alpha: 1)
+    /// Reaper lane background — the same green as a soft tint, so the sidecar
+    /// band reads at a glance without shouting.
+    static var reaperLaneBg: NSColor {
+        pick(NSColor(calibratedHue: 0.4325, saturation: 0.30, brightness: 0.185, alpha: 1),
+             NSColor(calibratedHue: 0.4325, saturation: 0.14, brightness: 0.80, alpha: 1))
+    }
+    /// The gaps BETWEEN reaper lanes (and behind them) — a green sitting
+    /// between the timeline background and the lane tint, so the sidecar
+    /// reads as one continuous band with green separators.
+    static var reaperSeparatorBg: NSColor {
+        pick(NSColor(calibratedHue: 0.4325, saturation: 0.40, brightness: 0.135, alpha: 1),
+             NSColor(calibratedHue: 0.4325, saturation: 0.20, brightness: 0.86, alpha: 1))
+    }
     static var rulerBg: NSColor {
         pick(NSColor(calibratedWhite: 0.13, alpha: 1), NSColor(calibratedWhite: 0.88, alpha: 1))
     }
@@ -86,16 +103,18 @@ enum Theme {
     }
 
     // Optimization strip (the thin band under the ruler). Muted so a mostly
-    // red/yellow strip informs rather than alarms.
-    /// Proxy built at the full preview-quality target.
+    // red/yellow strip informs rather than alarms. Hue encodes the TIER
+    // (cyan = proxy on disk, green = exact frame in RAM); the dark variant of
+    // each hue means "present, but at reduced quality".
+    /// Proxy on disk at the full preview-quality target.
     static var stripFull: NSColor {
-        pick(NSColor(calibratedHue: 0.36, saturation: 0.70, brightness: 0.62, alpha: 1),
-             NSColor(calibratedHue: 0.36, saturation: 0.65, brightness: 0.60, alpha: 1))
+        pick(NSColor(calibratedHue: 0.50, saturation: 0.70, brightness: 0.62, alpha: 1),
+             NSColor(calibratedHue: 0.50, saturation: 0.65, brightness: 0.60, alpha: 1))
     }
-    /// Proxy built below target — usable now, an upgrade is still queued.
+    /// Proxy on disk below target — usable now, an upgrade is still queued.
     static var stripUsable: NSColor {
-        pick(NSColor(calibratedHue: 0.36, saturation: 0.50, brightness: 0.42, alpha: 1),
-             NSColor(calibratedHue: 0.36, saturation: 0.40, brightness: 0.72, alpha: 1))
+        pick(NSColor(calibratedHue: 0.50, saturation: 0.55, brightness: 0.40, alpha: 1),
+             NSColor(calibratedHue: 0.50, saturation: 0.40, brightness: 0.74, alpha: 1))
     }
     /// Building right now (or a rescue slice standing in).
     static var stripBuilding: NSColor {
@@ -107,4 +126,16 @@ enum Theme {
         pick(NSColor(calibratedHue: 0.01, saturation: 0.65, brightness: 0.48, alpha: 1),
              NSColor(calibratedHue: 0.01, saturation: 0.55, brightness: 0.75, alpha: 1))
     }
+    /// Exact full-tier frame resident in the RAM cache — a seek here shows
+    /// the real frame instantly, no stand-in flash.
+    static var stripRAM: NSColor {
+        pick(NSColor(calibratedHue: 0.36, saturation: 0.70, brightness: 0.68, alpha: 1),
+             NSColor(calibratedHue: 0.36, saturation: 0.70, brightness: 0.55, alpha: 1))
+    }
+    /// RAM frame present but decoded from a reduced-tier source (below-target
+    /// chunk or rescue slice) — instant, but soft until it heals upward.
+    static var stripRAMLow: NSColor {
+        pick(NSColor(calibratedHue: 0.36, saturation: 0.55, brightness: 0.42, alpha: 1),
+             NSColor(calibratedHue: 0.36, saturation: 0.45, brightness: 0.72, alpha: 1))
+    }
 }
diff --git a/sequencer/Sources/Sequencer/TimelineView.swift b/sequencer/Sources/Sequencer/TimelineView.swift
index 0f15f3c8e770151703fd36ab4624ec3d20a79630..6c7f940b6d602d80a0728b4312e0449244874e4b 100644
--- a/sequencer/Sources/Sequencer/TimelineView.swift
+++ b/sequencer/Sources/Sequencer/TimelineView.swift
@@ -33,14 +33,21 @@ enum DrawProf {
 /// The timeline: ruler, Fusion comps band, track lanes, clips, playhead.
 /// Tracks are unnamed and color-coded; new tracks appear dynamically when a
 /// clip is dragged below the last lane (two rows down = two new tracks).
-/// Empty tracks are allowed. All edits are frame-quantized and run through
-/// Store gestures so every drag is one undo step.
+/// Empty tracks are allowed. Edits are frame-quantized (except audio-only
+/// move/trim, which is sub-frame — sound isn't bound to the frame grid) and
+/// run through Store gestures so every drag is one undo step.
 final class TimelineView: NSView {
 
     // View state
     private var pxPerSecond: Double = 20
     private var originSecond: Double = -1
     private var scrollY: CGFloat = 0     // vertical track scroll offset
+
+    /// True for an *extra* timeline window (View ▸ New Timeline Window) — a
+    /// second view onto the same document with its own zoom/scroll. Such a view
+    /// must not publish the proxy builder's `visibleTimeRange` heat anchor, or
+    /// two timelines would fight over it; the main window owns that signal.
+    var isSecondary = false
     private let rulerH: CGFloat = 26
     private let baseLaneH: CGFloat = 64
     private let laneGap: CGFloat = 4
@@ -151,8 +158,13 @@ final class TimelineView: NSView {
     }
 
     @objc private func playheadMoved() {
-        // Auto-follow while playing.
-        if playback.isPlaying {
+        // Auto-follow while playing — but only in the window you're actually
+        // driving (the key window), and never in an extra timeline window (a
+        // fixed second view). Playing from one window must not scroll the
+        // others: the root window stays put while you play in a subwindow, and
+        // extra windows stay put while you play in the root. Others still
+        // redraw so the playhead marker sweeps across their fixed view.
+        if playback.isPlaying, !isSecondary, window?.isKeyWindow == true {
             let x = xFor(playback.playhead)
             if x > bounds.width - 60 || x < headerW {
                 originSecond = playback.playhead
@@ -196,9 +208,16 @@ final class TimelineView: NSView {
     private var lanesTop: CGFloat { rulerH + stripH + fusionBandH }
 
     private func laneHeight(_ ref: TrackRef) -> CGFloat {
+        // Reaper lanes are compact by design: minimum height by default (an
+        // audio strip needs no filmstrip room), slivers when the sidecar band
+        // is collapsed. No per-lane resize — one merged logical track.
+        if ref.isReaper {
+            // Collapsed: just tall enough for a small-font label strip.
+            return quantized(session.reaperCollapsed ? 8 : 24)
+        }
         // Device-pixel quantized so lane rasters (scene tiles) blit without
         // resampling; the ≤ half-device-pixel rounding is imperceptible.
-        quantized(max(24, baseLaneH * session.laneScale * (session.trackHeights[ref] ?? 1)))
+        return quantized(max(24, baseLaneH * session.laneScale * (session.trackHeights[ref] ?? 1)))
     }
     private var defaultLaneH: CGFloat { quantized(max(24, baseLaneH * session.laneScale)) }
 
@@ -238,13 +257,15 @@ final class TimelineView: NSView {
     }
 
     /// Row whose bottom edge is under the cursor (for track-height resizing).
+    /// Reaper lanes are fixed-height (one merged logical track) — their
+    /// boundaries never grab.
     private func trackBoundaryAt(y: CGFloat) -> Int? {
         guard y > lanesTop else { return nil }
         let rows = laneRows
         var yy = lanesTop + laneGap - scrollY
         for (i, ref) in rows.enumerated() {
             yy += laneHeight(ref)
-            if abs(y - yy) <= 4 { return i }
+            if abs(y - yy) <= 4 { return ref.isReaper ? nil : i }
             yy += laneGap
         }
         return nil
@@ -274,6 +295,37 @@ final class TimelineView: NSView {
         return nil
     }
 
+    /// The clip whose in/out EDGE zone contains the point, preferring the
+    /// nearest edge across ALL clips stacked there — so a resize handle inside
+    /// an overlap grabs the clip that owns the edge, not whichever body draws
+    /// on top. Same 7 pt zone as the trim hit-test in `mouseDown`.
+    private func edgeClipAt(point p: NSPoint) -> (clip: Clip, row: Int)? {
+        guard let row = rowAt(y: p.y), let ref = laneRef(row: row) else { return nil }
+        rebuildSceneIfNeeded()
+        let edge: CGFloat = 7
+        var best: (clip: Clip, dist: CGFloat)?
+        for clip in clipsByLane[ref] ?? [] {
+            let rect = clipRect(clip, row: row)
+            guard rect.contains(p) else { continue }
+            for d in [p.x - rect.minX, rect.maxX - p.x] where d < edge {
+                if best == nil || d < best!.dist { best = (clip, d) }
+            }
+        }
+        return best.map { ($0.clip, row) }
+    }
+
+    /// The clip butted up against `clip`'s in (before: true) or out edge on
+    /// the same lane — the partner for a shared-boundary roll drag.
+    private func rollMate(of clip: Clip, before: Bool) -> Clip? {
+        guard clip.kind != .storyboard, !clip.track.isReaper else { return nil }
+        rebuildSceneIfNeeded()
+        let tol = max(0.001, 0.75 / pxPerSecond)
+        return (clipsByLane[clip.track] ?? []).first {
+            $0.id != clip.id && $0.kind != .storyboard
+                && abs(before ? $0.end - clip.start : $0.start - clip.end) < tol
+        }
+    }
+
     private func overlapAt(point: NSPoint) -> ClipOverlap? {
         guard let row = rowAt(y: point.y), let ref = laneRef(row: row) else { return nil }
         rebuildSceneIfNeeded()
@@ -318,6 +370,12 @@ final class TimelineView: NSView {
         .font: NSFont.systemFont(ofSize: 9.5, weight: .medium),
         .foregroundColor: NSColor(calibratedWhite: 0.92, alpha: 1),
     ]
+    /// Collapsed reaper lanes are only 8 pt tall — their labels use this
+    /// smaller face so the names stay in view.
+    private static let titleAttrsSmall: [NSAttributedString.Key: Any] = [
+        .font: NSFont.systemFont(ofSize: 6.5, weight: .medium),
+        .foregroundColor: NSColor(calibratedWhite: 0.92, alpha: 1),
+    ]
 
     /// Clip titles as cached CTLines. `NSString.draw` runs a full CoreText
     /// layout per call — ~200 visible labels re-laid-out every cold frame,
@@ -326,25 +384,26 @@ final class TimelineView: NSView {
     /// titles are media names + panel names, a small closed set in practice.
     private static var titleLineCache: [String: (line: CTLine, ascent: CGFloat)] = [:]
     private static let titleLineLock = NSLock()   // lanes rasterize in parallel
-    private static func titleLine(_ s: String) -> (line: CTLine, ascent: CGFloat) {
+    private static func titleLine(_ s: String, small: Bool = false) -> (line: CTLine, ascent: CGFloat) {
         titleLineLock.lock()
         defer { titleLineLock.unlock() }
-        if let c = titleLineCache[s] { return c }
+        let key = small ? "\u{1}" + s : s
+        if let c = titleLineCache[key] { return c }
         if titleLineCache.count > 512 { titleLineCache.removeAll(keepingCapacity: true) }
         let line = CTLineCreateWithAttributedString(
-            NSAttributedString(string: s, attributes: titleAttrs))
+            NSAttributedString(string: s, attributes: small ? titleAttrsSmall : titleAttrs))
         var ascent: CGFloat = 0
         CTLineGetTypographicBounds(line, &ascent, nil, nil)
         let entry = (line, ascent)
-        titleLineCache[s] = entry
+        titleLineCache[key] = entry
         return entry
     }
 
     /// Draw a cached title line with its top-left at `point` in the flipped
     /// view space — positioned to match what `NSString.draw(at:)` produced.
-    private func drawTitle(_ s: String, at point: NSPoint) {
+    private func drawTitle(_ s: String, at point: NSPoint, small: Bool = false) {
         guard let cg = NSGraphicsContext.current?.cgContext else { return }
-        let (line, ascent) = Self.titleLine(s)
+        let (line, ascent) = Self.titleLine(s, small: small)
         cg.saveGState()
         // Flipped context: un-flip locally for glyph drawing. The box-top to
         // baseline offset is the line's ascent, matching NSString.draw(at:).
@@ -453,13 +512,7 @@ final class TimelineView: NSView {
         // frame. Compute them once per lane here.
         laneColorCache = [:]
         for ref in laneRows {
-            let base = trackColor(ref)
-            laneColorCache[ref] = LaneColors(
-                base: base,
-                videoBody: base.blended(withFraction: 0.75, of: .black) ?? base,
-                audioBody: base.blended(withFraction: 0.82, of: .black) ?? base,
-                strip: (base.blended(withFraction: 0.5, of: .black) ?? base)
-                    .withAlphaComponent(0.85))
+            laneColorCache[ref] = Self.computeLaneColors(ref, base: trackColor(ref))
         }
         sceneDirty = false
     }
@@ -470,16 +523,28 @@ final class TimelineView: NSView {
         let audioBody: NSColor   // audio clip body fill
         let strip: NSColor       // title-strip fill
     }
-    private var laneColorCache: [TrackRef: LaneColors] = [:]
-    private func laneColors(_ ref: TrackRef) -> LaneColors {
-        if let c = laneColorCache[ref] { return c }
-        let base = trackColor(ref)
+    private static func computeLaneColors(_ ref: TrackRef, base: NSColor) -> LaneColors {
+        if ref.isReaper {
+            // Reaper clips are the hardcoded sidecar green; ink (waveform,
+            // borders, strip) goes DARK so it reads on the bright body.
+            let g = Theme.reaperGreen
+            return LaneColors(
+                base: g.blended(withFraction: 0.55, of: .black) ?? g,
+                videoBody: g,
+                audioBody: g,
+                strip: (g.blended(withFraction: 0.68, of: .black) ?? g)
+                    .withAlphaComponent(0.85))
+        }
         return LaneColors(base: base,
                           videoBody: base.blended(withFraction: 0.75, of: .black) ?? base,
                           audioBody: base.blended(withFraction: 0.82, of: .black) ?? base,
                           strip: (base.blended(withFraction: 0.5, of: .black) ?? base)
                               .withAlphaComponent(0.85))
     }
+    private var laneColorCache: [TrackRef: LaneColors] = [:]
+    private func laneColors(_ ref: TrackRef) -> LaneColors {
+        laneColorCache[ref] ?? Self.computeLaneColors(ref, base: trackColor(ref))
+    }
 
     /// Clips intersecting the visible time window, across all lanes. Cheap: the
     /// per-lane arrays are sorted, so it culls the same way the draw loop does.
@@ -554,6 +619,10 @@ final class TimelineView: NSView {
     /// paths inside one process (immune to thermal drift between runs).
     static var tilesDisabled =
         ProcessInfo.processInfo.environment["SEQ_NOTILES"] == "1"
+    /// SEQ_NOPARALLEL=1 renders cold frames serially — for bisecting
+    /// concurrency bugs in the parallel lane rasterizer.
+    static var parallelDisabled =
+        ProcessInfo.processInfo.environment["SEQ_NOPARALLEL"] == "1"
 
     private func flushTiles() {
         tiles.removeAll(keepingCapacity: true)
@@ -722,9 +791,12 @@ final class TimelineView: NSView {
 
         // Publish the on-screen time span — a heat anchor for the proxy
         // builder (the user scrubs inside what they can see). Cheap enough
-        // to set every frame; read lazily by the chunk scheduler.
-        let visibleSpan = Double(bounds.width - headerW) / pxPerSecond
-        ctx.session.visibleTimeRange = originSecond...(originSecond + max(1, visibleSpan))
+        // to set every frame; read lazily by the chunk scheduler. Only the
+        // main timeline owns this signal (see `isSecondary`).
+        if !isSecondary {
+            let visibleSpan = Double(bounds.width - headerW) / pxPerSecond
+            ctx.session.visibleTimeRange = originSecond...(originSecond + max(1, visibleSpan))
+        }
 
         DrawProf.t("scene") { rebuildSceneIfNeeded() }
         DrawProf.t("cull") {
@@ -806,6 +878,7 @@ final class TimelineView: NSView {
             drawSnapIndicator()
             drawBoxSelect()
             drawPlayhead()
+            drawDragReadout()
         }
         DrawProf.t("scrollbars") { drawScrollbars() }
     }
@@ -897,7 +970,9 @@ final class TimelineView: NSView {
     private func drawLane(row: Int, ref: TrackRef, tiled: Bool) {
         let lane = laneRect(row: row)
         guard lane.minY < bounds.maxY, lane.maxY > lanesTop else { return }
-        (ref == .storyboard ? Theme.storyboardLaneBg : Theme.laneBg).setFill()
+        if ref.reaperIndex == 0 { fillReaperBand(firstLane: lane) }
+        (ref == .storyboard ? Theme.storyboardLaneBg
+            : ref.isReaper ? Theme.reaperLaneBg : Theme.laneBg).setFill()
         NSBezierPath(roundedRect: lane, xRadius: 4, yRadius: 4).fill()
 
         if tiled {
@@ -909,10 +984,50 @@ final class TimelineView: NSView {
         drawLaneDecorations(ref: ref, lane: lane)
     }
 
+    /// One continuous green wash behind the whole sidecar band, so the GAPS
+    /// between reaper lanes read green too and the lanes merge into one
+    /// logical track. Drawn under the per-lane fills (reaper lanes are
+    /// contiguous in `laneRefs`).
+    private func fillReaperBand(firstLane: NSRect) {
+        guard let last = laneRows.lastIndex(where: { $0.isReaper }) else { return }
+        let bottom = laneRect(row: last).maxY
+        let band = NSRect(x: firstLane.minX, y: firstLane.minY,
+                          width: firstLane.width, height: bottom - firstLane.minY)
+        Theme.reaperSeparatorBg.setFill()
+        NSBezierPath(roundedRect: band, xRadius: 4, yRadius: 4).fill()
+    }
+
+    /// The merged header strip spanning every reaper lane, and the single
+    /// collapse toggle at its top. One source of truth for draw + hit-test.
+    private var reaperHeaderRect: NSRect? {
+        guard let first = laneRows.firstIndex(where: { $0.isReaper }),
+              let last = laneRows.lastIndex(where: { $0.isReaper }) else { return nil }
+        let top = laneRect(row: first)
+        let bottom = laneRect(row: last)
+        return NSRect(x: 0, y: top.minY, width: headerW, height: bottom.maxY - top.minY)
+    }
+    private var reaperCollapseRect: NSRect? {
+        guard let h = reaperHeaderRect else { return nil }
+        // Center the chevron when the collapsed band is shorter than the
+        // usual top inset would allow.
+        let y = h.minY + min(4, max(0, (h.height - 16) / 2))
+        return NSRect(x: headerW / 2 - 8, y: y, width: 16, height: 16)
+    }
+
     /// Pinned labels + overlap bands — main-thread, over blits or direct clips.
     private func drawLaneDecorations(ref: TrackRef, lane: NSRect) {
         drawPinnedLabels(ref: ref, lane: lane)
 
+        // Live drop-export feedback: the reaper lane an audio clip is hovering
+        // glows green — release to bake it into the sidecar.
+        if let rd = drag.reaperDrop, ref == .reaper(rd.lane) {
+            Theme.reaperGreen.withAlphaComponent(0.9).setStroke()
+            let p = NSBezierPath(roundedRect: lane.insetBy(dx: 1.25, dy: 1.25),
+                                 xRadius: 4, yRadius: 4)
+            p.lineWidth = 2.5
+            p.stroke()
+        }
+
         // Bright red overlap ranges on top of the clip bodies.
         for o in overlapsByLane[ref] ?? [] {
             let r = NSRect(x: xFor(o.start), y: lane.minY + 1,
@@ -945,7 +1060,9 @@ final class TimelineView: NSView {
         for (row, ref) in rows.enumerated() {
             let lane = laneRect(row: row)
             guard lane.minY < bounds.maxY, lane.maxY > lanesTop else { continue }
-            (ref == .storyboard ? Theme.storyboardLaneBg : Theme.laneBg).setFill()
+            if ref.reaperIndex == 0 { fillReaperBand(firstLane: lane) }
+            (ref == .storyboard ? Theme.storyboardLaneBg
+                : ref.isReaper ? Theme.reaperLaneBg : Theme.laneBg).setFill()
             NSBezierPath(roundedRect: lane, xRadius: 4, yRadius: 4).fill()
             work.append((ref, lane))
         }
@@ -971,7 +1088,12 @@ final class TimelineView: NSView {
             return c
         }
 
-        DispatchQueue.concurrentPerform(iterations: work.count) { i in
+        // SEQ_NOPARALLEL=1: render the cold-frame lanes serially (same code,
+        // same buffers) — the A/B switch for isolating concurrency bugs.
+        let iterate: (Int, (Int) -> Void) -> Void = Self.parallelDisabled
+            ? { n, body in for i in 0..<n { body(i) } }
+            : DispatchQueue.concurrentPerform
+        iterate(work.count) { i in
             guard let cg = ctxs[i] else { return }   // storyboard → main below
             let (ref, lane) = work[i]
             autoreleasepool {
@@ -1037,13 +1159,64 @@ final class TimelineView: NSView {
             if clip.end < leftSec { continue }
             let hasPrevPanel = ref == .storyboard && i > 0
                 && clips[0].start < clip.start - 1e-6
+            // Adjacent same-lane clips that TOUCH (on-screen gap < ~1px) render
+            // seamless: no inter-card gap, a single shared border at the cut
+            // instead of two card edges with background between. The tolerance
+            // grows as you zoom out (1px in time), so a sub-pixel gap never
+            // looks like a cut.
+            var joinLeft = false, joinRight = false
+            var isRunStart = true
+            var runEndSec = clip.end
+            if clip.kind != .storyboard {
+                let tol = 1.0 / pxPerSecond
+                if i > 0, clips[i - 1].kind != .storyboard,
+                   abs(clips[i - 1].end - clip.start) < tol { joinLeft = true }
+                if i + 1 < clips.count, clips[i + 1].kind != .storyboard,
+                   abs(clip.end - clips[i + 1].start) < tol { joinRight = true }
+                // Same-media touching run: only the first clip labels it, so a
+                // dozen adjacent "cam.mov" cuts read as one name, and the run's
+                // extent (`runEndSec`) lets that name overflow narrow cuts.
+                if joinLeft, clip.mediaId != nil, clips[i - 1].mediaId == clip.mediaId {
+                    isRunStart = false
+                }
+                if isRunStart, clip.mediaId != nil {
+                    var j = i
+                    while j + 1 < clips.count, clips[j + 1].mediaId == clip.mediaId,
+                          abs(clips[j].end - clips[j + 1].start) < tol {
+                        j += 1; runEndSec = clips[j].end
+                    }
+                }
+            }
             drawClip(clip, lane: lane, ref: ref, colors: colors,
                      overlapping: overlappingIds.contains(clip.id),
-                     hasPrevPanel: hasPrevPanel,
+                     hasPrevPanel: hasPrevPanel, joinLeft: joinLeft, joinRight: joinRight,
+                     isRunStart: isRunStart, runEndSec: runEndSec,
                      cullX0: cullX0 - bleed, cullX1: cullX1 + bleed)
         }
     }
 
+    /// Rounded-rect path with rounding suppressed on the left and/or right side,
+    /// so a clip touching a neighbour squares off the shared edge and the run
+    /// reads as one continuous card. Tangent arcs → coordinate-system agnostic
+    /// (the timeline view is flipped).
+    private func cardPath(_ r: NSRect, radius: CGFloat,
+                          roundLeft: Bool, roundRight: Bool) -> NSBezierPath {
+        let rl = roundLeft ? min(radius, r.width / 2) : 0
+        let rr = roundRight ? min(radius, r.width / 2) : 0
+        let p = NSBezierPath()
+        p.move(to: NSPoint(x: r.minX + rl, y: r.minY))
+        p.line(to: NSPoint(x: r.maxX - rr, y: r.minY))
+        p.appendArc(from: NSPoint(x: r.maxX, y: r.minY), to: NSPoint(x: r.maxX, y: r.minY + rr), radius: rr)
+        p.line(to: NSPoint(x: r.maxX, y: r.maxY - rr))
+        p.appendArc(from: NSPoint(x: r.maxX, y: r.maxY), to: NSPoint(x: r.maxX - rr, y: r.maxY), radius: rr)
+        p.line(to: NSPoint(x: r.minX + rl, y: r.maxY))
+        p.appendArc(from: NSPoint(x: r.minX, y: r.maxY), to: NSPoint(x: r.minX, y: r.maxY - rl), radius: rl)
+        p.line(to: NSPoint(x: r.minX, y: r.minY + rl))
+        p.appendArc(from: NSPoint(x: r.minX, y: r.minY), to: NSPoint(x: r.minX + rl, y: r.minY), radius: rl)
+        p.close()
+        return p
+    }
+
     /// Circular SF-Symbol button in the header column (hide preview / focus).
     private func drawHeaderButton(_ symbolName: String, centerY: CGFloat, on: Bool) {
         drawHeaderButton(symbolName, in: NSRect(x: headerW / 2 - 8.5, y: centerY - 8.5,
@@ -1093,6 +1266,20 @@ final class TimelineView: NSView {
     }
 
     private func drawTrackHeader(row: Int, ref: TrackRef, lane: NSRect) {
+        // The sidecar draws ONE merged header for all its lanes: a single
+        // green strip with a lone collapse toggle — no hide/focus/colour
+        // buttons (the .rpp owns those lanes; there's nothing to configure).
+        if ref.isReaper {
+            guard ref.reaperIndex == 0, let strip = reaperHeaderRect else { return }
+            Theme.reaperGreen.setFill()
+            NSBezierPath(roundedRect: strip.insetBy(dx: 2, dy: 2),
+                         xRadius: 3, yRadius: 3).fill()
+            if let r = reaperCollapseRect {
+                drawHeaderButton(session.reaperCollapsed ? "chevron.down" : "chevron.up",
+                                 in: r, on: false)
+            }
+            return
+        }
         // Header column: track color strip with hide (eye.slash), focus
         // (expand), and — when there's room — a colour swatch for the picker.
         let hidden = session.hiddenTracks.contains(ref)
@@ -1191,6 +1378,8 @@ final class TimelineView: NSView {
 
     private func drawClip(_ clip: Clip, lane: NSRect, ref: TrackRef, colors: LaneColors,
                           overlapping: Bool, hasPrevPanel: Bool,
+                          joinLeft: Bool = false, joinRight: Bool = false,
+                          isRunStart: Bool = true, runEndSec: Double = 0,
                           cullX0: CGFloat, cullX1: CGFloat) {
         let x0 = xFor(clip.start), x1 = xFor(clip.end)
         let rect = NSRect(x: x0, y: lane.minY, width: max(2, x1 - x0), height: lane.height)
@@ -1206,7 +1395,11 @@ final class TimelineView: NSView {
         let storyboard = clip.kind == .storyboard
 
         func bodyFillColor() -> NSColor {
-            switch clip.kind {
+            // Ghost reaper items (MIDI etc. living only in the .rpp) draw as a
+            // faded solid — the composite of the green over the reaper lane —
+            // so tiles and the pinned-label patch reproduce it exactly.
+            if clip.reaperGhost { return Self.reaperGhostBody }
+            return switch clip.kind {
             case .storyboard: NSColor(calibratedWhite: 0.88, alpha: 1)
             case .audio: colors.audioBody
             case .video: media == nil ? NSColor(calibratedWhite: 0.25, alpha: 1)
@@ -1226,10 +1419,14 @@ final class TimelineView: NSView {
             bodyFillColor().setFill()
             rect.fill()
             colors.strip.setFill()
-            NSRect(x: rect.minX, y: rect.minY, width: rect.width, height: 13).fill()
+            NSRect(x: rect.minX, y: rect.minY, width: rect.width,
+                   height: min(13, rect.height)).fill()
             if clip.kind == .audio {
                 color.withAlphaComponent(0.35).setFill()
-                NSRect(x: rect.minX, y: rect.midY + 6, width: rect.width, height: 1).fill()
+                // Clamp to the lane: on a collapsed reaper sliver midY+6 would
+                // land in the gap below.
+                NSRect(x: rect.minX, y: rect.midY + 6, width: rect.width, height: 1)
+                    .intersection(rect).fill()
                 // Fade-handle slivers: the full path clips the 7 px handle
                 // ovals to the clip body, so at this width only a couple of
                 // white columns survive — the speckle texture of a dense audio
@@ -1242,6 +1439,11 @@ final class TimelineView: NSView {
                     if !sliver.isEmpty { sliver.fill() }
                 }
             }
+            // Muted clips dim so the state reads at ANY zoom (no badge to lose).
+            if clip.muted {
+                NSColor(calibratedWhite: 0.03, alpha: 0.5).setFill()
+                rect.fill()
+            }
             // Status tint only: at this width the border stroke's inset path is
             // degenerate (sub-zero width) and renders nothing today, and the
             // red overlap band is painted at lane level. The tint is what reads.
@@ -1269,14 +1471,23 @@ final class TimelineView: NSView {
             return NSRect(x: cx0, y: rect.minY, width: cx1 - cx0, height: rect.height)
         }()
 
-        let bodyRect = storyboard
+        // Joined edges reach the true clip boundary (no 0.5 inset) so touching
+        // clips' bodies meet exactly and their corners square off.
+        let bodyRect: NSRect = storyboard
             ? NSRect(x: cardRect.minX, y: cardRect.minY + 0.5,
                      width: cardRect.width, height: cardRect.height - 1)
-            : cardRect.insetBy(dx: 0.5, dy: 0.5)
+            : {
+                let lx = cardRect.minX + (joinLeft ? 0 : 0.5)
+                let rx = cardRect.maxX - (joinRight ? 0 : 0.5)
+                return NSRect(x: lx, y: cardRect.minY + 0.5, width: rx - lx,
+                              height: cardRect.height - 1)
+            }()
         let bodyRadius: CGFloat = storyboard ? 0 : 3
         let body = DrawProf.t("clip.body") {
-            let p = NSBezierPath(roundedRect: bodyRect, xRadius: bodyRadius,
-                                 yRadius: bodyRadius)
+            let p = storyboard
+                ? NSBezierPath(rect: bodyRect)
+                : cardPath(bodyRect, radius: bodyRadius,
+                           roundLeft: !joinLeft, roundRight: !joinRight)
             bodyFillColor().setFill()
             p.fill()
             return p
@@ -1295,6 +1506,8 @@ final class TimelineView: NSView {
                 if let media {
                     drawWaveform(clip, media: media, rect: rect, color: color,
                                  cullX0: cullX0, cullX1: cullX1)
+                } else if clip.reaperGhost {
+                    drawGhostHatch(rect, ink: color, cullX0: cullX0, cullX1: cullX1)
                 }
                 drawFades(clip, rect: rect, selected: selected)
             case .storyboard:
@@ -1303,49 +1516,68 @@ final class TimelineView: NSView {
             NSGraphicsContext.current?.restoreGraphicsState()
         }
 
-        // Title strip
+        // Title strip. The strip BACKGROUND is per-clip (clipped to this body),
+        // but the NAME is drawn once per same-media run and allowed to overflow
+        // the narrow cuts (clipped to the run's span), so "cam.mov" stays
+        // readable instead of a row of truncated repeats. A clip scrolled off
+        // the left edge gets its run name re-pinned by `drawPinnedLabels`.
         let title = clipTitle(clip, media: media)
-        // The label is drawn only when the clip is wide enough to read; a clip
-        // narrower than this shows no legible text anyway.
-        let showLabel = rect.width >= 22
+        // Collapsed reaper lanes are shorter than the standard 13 pt strip —
+        // the strip shrinks to the lane and the label drops to the small face.
+        let smallTitle = ref.isReaper && session.reaperCollapsed
+        let stripH = min(13, rect.height)
         DrawProf.t("clip.strip") {
-        NSGraphicsContext.current?.saveGraphicsState()
-        body.addClip()
-        colors.strip.setFill()
-        NSRect(x: cardRect.minX, y: cardRect.minY, width: cardRect.width, height: 13).fill()
-        if showLabel {
-            // Unpinned: the label sits at the clip's true left edge. A clip
-            // scrolled off the left edge gets its label re-pinned to the view
-            // edge by `drawPinnedLabels` — an overlay pass, so the pinning
-            // never gets baked into a cached tile.
-            drawTitle(title, at: NSPoint(x: rect.minX + 5, y: rect.minY + 1))
+            NSGraphicsContext.current?.saveGraphicsState()
+            body.addClip()
+            colors.strip.setFill()
+            NSRect(x: cardRect.minX, y: cardRect.minY, width: cardRect.width, height: stripH).fill()
+            NSGraphicsContext.current?.restoreGraphicsState()
 
-            var badgeX = rect.maxX - 16
-            if clip.speed != 1 {
+            let runMaxX = min(isRunStart ? xFor(runEndSec) : rect.maxX, bounds.width + 8)
+            if isRunStart, runMaxX - rect.minX >= 22 {
+                NSGraphicsContext.current?.saveGraphicsState()
+                NSRect(x: rect.minX, y: rect.minY, width: runMaxX - rect.minX, height: stripH).clip()
+                drawTitle(title, at: NSPoint(x: rect.minX + 5, y: rect.minY + (smallTitle ? 0.5 : 1)),
+                          small: smallTitle)
+                // Text beats the link glyph: it only draws if the run has room
+                // after the name (and subtly — the link tint on select is the
+                // real cue).
+                if clip.linkId != nil, !smallTitle, let img = Self.linkBadge {
+                    let lx = rect.minX + 5 + title.size(withAttributes: Self.titleAttrs).width + 4
+                    if lx + 11 <= runMaxX {
+                        img.draw(in: NSRect(x: lx, y: rect.minY + 2, width: 10, height: 10),
+                                 from: .zero, operation: .sourceOver, fraction: 0.5)
+                    }
+                }
+                NSGraphicsContext.current?.restoreGraphicsState()
+            }
+            // Speed is per-clip; keep it at the right edge when the clip is wide
+            // enough to not crowd the name.
+            if clip.speed != 1, rect.width >= 34 {
                 let s = String(format: "×%.4g", clip.speed)
                 let sAttrs: [NSAttributedString.Key: Any] = [
                     .font: NSFont.monospacedDigitSystemFont(ofSize: 8.5, weight: .semibold),
                     .foregroundColor: FusionComps.yellow,
                 ]
                 let w = s.size(withAttributes: sAttrs).width
-                badgeX -= w
-                s.draw(at: NSPoint(x: badgeX, y: rect.minY + 1.5), withAttributes: sAttrs)
-                badgeX -= 5
+                NSGraphicsContext.current?.saveGraphicsState()
+                body.addClip()
+                s.draw(at: NSPoint(x: rect.maxX - w - 4, y: rect.minY + 1.5), withAttributes: sAttrs)
+                NSGraphicsContext.current?.restoreGraphicsState()
             }
-            if clip.muted, let img = Self.mutedBadge {
-                img.draw(in: NSRect(x: badgeX, y: rect.minY + 2, width: 10, height: 10),
-                         from: .zero, operation: .sourceOver, fraction: 0.9)
-                badgeX -= 13
-            }
-            if clip.linkId != nil, let img = Self.linkBadge {
-                img.draw(in: NSRect(x: badgeX, y: rect.minY + 2, width: 10, height: 10),
-                         from: .zero, operation: .sourceOver, fraction: 0.7)
-            }
-        }
-        NSGraphicsContext.current?.restoreGraphicsState()
         }
 
         DrawProf.t("clip.chrome") {
+        // Muted clips dim the whole card so the state reads at ANY zoom, with
+        // no badge to lose — under the selection tint and border so those stay
+        // crisp.
+        if clip.muted {
+            NSGraphicsContext.current?.saveGraphicsState()
+            body.addClip()
+            NSColor(calibratedWhite: 0.03, alpha: 0.5).setFill()
+            cardRect.fill()
+            NSGraphicsContext.current?.restoreGraphicsState()
+        }
         // Selection reads as a full-card tint, not just an outline. Link-mates
         // of the selection (they act selected) tint aqua.
         if selected || linkedSel {
@@ -1363,8 +1595,19 @@ final class TimelineView: NSView {
         // outline (selected / linked / overlapping).
         if !storyboard || selected || linkedSel || overlapping {
             let radius: CGFloat = storyboard ? 0 : 3
-            let border = NSBezierPath(roundedRect: cardRect.insetBy(dx: 1.25, dy: 1.25),
+            // Joined edges put the border AT the shared boundary, so the two
+            // neighbours' borders coincide into a single cut line (no gap).
+            let border: NSBezierPath
+            if storyboard {
+                border = NSBezierPath(roundedRect: cardRect.insetBy(dx: 1.25, dy: 1.25),
                                       xRadius: radius, yRadius: radius)
+            } else {
+                let lx = cardRect.minX + (joinLeft ? 0 : 1.25)
+                let rx = cardRect.maxX - (joinRight ? 0 : 1.25)
+                let br = NSRect(x: lx, y: cardRect.minY + 1.25, width: rx - lx,
+                                height: cardRect.height - 2.5)
+                border = cardPath(br, radius: radius, roundLeft: !joinLeft, roundRight: !joinRight)
+            }
             border.lineWidth = selected ? 3.5 : linkedSel ? 3 : (overlapping ? 2 : 1.5)
             (selected ? Theme.selection
                 : linkedSel ? NSColor.systemCyan
@@ -1377,14 +1620,50 @@ final class TimelineView: NSView {
     }
 
     private func clipTitle(_ clip: Clip, media: MediaItem?) -> String {
+        // Ghost reaper items have no media by design — label from the .rpp.
+        if clip.reaperGhost { return "◇ " + (clip.reaperName ?? "REAPER item") }
         var title = media?.displayName
+            ?? clip.reaperName
             ?? (clip.kind == .storyboard
                 ? (panelNamesCache[clip.id] ?? "Panel") : "missing media")
-        if clip.kind != .storyboard && media == nil { title = "⚠︎ " + title }
+        if clip.kind != .storyboard && media == nil && clip.reaperName == nil {
+            title = "⚠︎ " + title
+        }
         if clip.kind == .audio { title = "♪ " + title }
         return title
     }
 
+    /// The solid a ghost reaper clip fills with: reaper green faded into the
+    /// reaper lane background (precomposited so every render path — direct,
+    /// tile, pinned patch — paints identical pixels).
+    private static var reaperGhostBody: NSColor {
+        Theme.reaperLaneBg.blended(withFraction: 0.30, of: Theme.reaperGreen)
+            ?? Theme.reaperGreen
+    }
+
+    /// Diagonal hatch for ghost items — "there's something here, but its
+    /// contents live in REAPER". Phase-anchored to the clip's left edge so it
+    /// doesn't swim under pan; clamped to the cull window (rects can be
+    /// millions of points wide when zoomed).
+    private func drawGhostHatch(_ rect: NSRect, ink: NSColor,
+                                cullX0: CGFloat, cullX1: CGFloat) {
+        let spacing: CGFloat = 8
+        let x0 = max(rect.minX, cullX0 - rect.height - spacing)
+        let x1 = min(rect.maxX, cullX1 + spacing)
+        guard x1 > x0 else { return }
+        let phase = (x0 - rect.minX).truncatingRemainder(dividingBy: spacing)
+        let path = NSBezierPath()
+        path.lineWidth = 1
+        var x = x0 - phase
+        while x < x1 {
+            path.move(to: NSPoint(x: x, y: rect.minY))
+            path.line(to: NSPoint(x: x + rect.height, y: rect.maxY))
+            x += spacing
+        }
+        ink.withAlphaComponent(0.30).setStroke()
+        path.stroke()
+    }
+
     /// Re-pin the title of any clip whose left edge is scrolled offscreen: the
     /// label follows the view edge (as it always has), but the pinning is an
     /// overlay so it is never baked into a scene tile. The patch repaints the
@@ -1403,16 +1682,31 @@ final class TimelineView: NSView {
             let x0 = xFor(clip.start), x1 = xFor(clip.end)
             let rect = NSRect(x: x0, y: lane.minY, width: max(2, x1 - x0),
                               height: lane.height)
-            guard rect.width >= 22 else { continue }
+            // The straddling clip may be mid-run — pin the RUN's name, and let
+            // it read across the run's span (not just this narrow cut).
+            var runEndSec = clip.end
+            if clip.mediaId != nil {
+                let tol = 1.0 / pxPerSecond
+                var j = i
+                while j + 1 < clips.count, clips[j + 1].mediaId == clip.mediaId,
+                      abs(clips[j].end - clips[j + 1].start) < tol {
+                    j += 1; runEndSec = clips[j].end
+                }
+            }
+            let runEndX = min(xFor(runEndSec), bounds.width)
+            guard runEndX - headerW >= 22 else { continue }
             let media = clip.mediaId.flatMap { mediaById[$0] }
             let title = clipTitle(clip, media: media)
             let selected = store.selection.contains(clip.id)
             let linkedSel = !selected && linkedSelectionCache.contains(clip.id)
             let overlapping = (overlapIdsByLane[ref] ?? []).contains(clip.id)
 
-            let labelW = title.size(withAttributes: Self.titleAttrs).width
+            let smallTitle = ref.isReaper && session.reaperCollapsed
+            let stripH = min(13, rect.height)
+            let labelW = title.size(withAttributes: smallTitle ? Self.titleAttrsSmall
+                                                               : Self.titleAttrs).width
             let patch = NSRect(x: headerW, y: rect.minY,
-                               width: min(labelW + 12, rect.maxX - headerW), height: 13)
+                               width: min(labelW + 12, rect.maxX - headerW), height: stripH)
             let storyboard = clip.kind == .storyboard
             let cx1 = min(rect.maxX, bounds.width + 12)
             let cardRect = NSRect(x: max(rect.minX, headerW - 12), y: rect.minY,
@@ -1430,16 +1724,19 @@ final class TimelineView: NSView {
                    height: patch.height).clip()
             body.addClip()
             // Rebuild the strip composite: body color under the 0.85-alpha strip.
-            switch clip.kind {
-            case .storyboard: NSColor(calibratedWhite: 0.88, alpha: 1).setFill()
-            case .audio: colors.audioBody.setFill()
-            case .video: (media == nil ? NSColor(calibratedWhite: 0.25, alpha: 1)
-                                       : colors.videoBody).setFill()
+            if clip.reaperGhost {
+                Self.reaperGhostBody.setFill()
+            } else {
+                switch clip.kind {
+                case .storyboard: NSColor(calibratedWhite: 0.88, alpha: 1).setFill()
+                case .audio: colors.audioBody.setFill()
+                case .video: (media == nil ? NSColor(calibratedWhite: 0.25, alpha: 1)
+                                           : colors.videoBody).setFill()
+                }
             }
             patch.fill()
             colors.strip.setFill()
             patch.fill()
-            drawTitle(title, at: NSPoint(x: headerW + 5, y: rect.minY + 1))
             if selected || linkedSel {
                 (selected ? NSColor.controlAccentColor : NSColor.systemCyan)
                     .withAlphaComponent(selected ? 0.34 : 0.20).setFill()
@@ -1447,6 +1744,15 @@ final class TimelineView: NSView {
             }
             NSGraphicsContext.current?.restoreGraphicsState()
 
+            // The name itself is clipped to the RUN span (the strip under it is
+            // already the same-media run's baked strip), so it reads in full even
+            // when the straddling cut is only a few pixels wide.
+            NSGraphicsContext.current?.saveGraphicsState()
+            NSRect(x: headerW, y: rect.minY, width: runEndX - headerW, height: stripH).clip()
+            drawTitle(title, at: NSPoint(x: headerW + 5, y: rect.minY + (smallTitle ? 0.5 : 1)),
+                      small: smallTitle)
+            NSGraphicsContext.current?.restoreGraphicsState()
+
             // Restroke the border segment the patch painted over — clipped to
             // the patch only (drawClip strokes the border unclipped, so a
             // body clip here would shave its outer antialiasing).
@@ -1481,10 +1787,24 @@ final class TimelineView: NSView {
         }
     }
 
+    /// True while a gesture that changes which SOURCE frames a clip shows
+    /// (slip, trim, ripple, stretch) is live on `clip` or one of its link-mates
+    /// — the cue to render frame-accurate thumbnails so the frames visibly move.
+    private func isResizingSource(_ clip: Clip) -> Bool {
+        switch drag.mode {
+        case .slip, .trimIn, .trimOut, .rippleIn, .rippleOut, .roll, .stretchIn, .stretchOut:
+            return clip.id == drag.clipId || drag.origSelection[clip.id] != nil
+        default:
+            return false
+        }
+    }
+
     private func drawFilmstrip(_ clip: Clip, media: MediaItem, rect: NSRect,
                                cullX0: CGFloat, cullX1: CGFloat) {
         let thumbH = rect.height - 14
         guard thumbH > 6 else { return }
+        // On screen right now → build its strip ahead of off-screen media.
+        MediaPipeline.shared.prioritizeMedia(media)
         let mediaAspect = media.width > 0 && media.height > 0
             ? CGFloat(media.width) / CGFloat(media.height) : 16.0 / 9.0
         let thumbW = thumbH * mediaAspect
@@ -1492,11 +1812,36 @@ final class TimelineView: NSView {
         // thumbnails never slide as the window changes); the window only culls.
         let visX0 = max(rect.minX, cullX0), visX1 = min(rect.maxX, cullX1)
         guard let cg = NSGraphicsContext.current?.cgContext else { return }
+        // At tight zoom a fine thumb (0.5 s) spans several pixels, so it's worth
+        // the viewport-driven fine tier — request it for the visible source span
+        // and prefer it per cell (coarse keyframe strip is the always-there
+        // fallback). This is what lets a trim/slip visibly shift the picture.
+        let fineThumbPx = Double(pxPerSecond) / max(0.001, clip.speed) * MediaPipeline.fineThumbInterval
+        let useFine = fineThumbPx >= 8
+        let sA = clip.sourceTime(at: max(secondsFor(visX0), clip.start))
+        let sB = clip.sourceTime(at: min(secondsFor(visX1), clip.end))
+        let srcLo = max(0, min(sA, sB)), srcHi = max(sA, sB)
+        if useFine {
+            MediaPipeline.shared.requestFineWindow(for: media, from: srcLo, to: srcHi)
+        }
+        // While this clip is being resized/slipped, fill its visible source span
+        // (plus a margin, since slip reveals source beyond the current edges) at
+        // ONE thumb per source frame, and prefer those — so the frames literally
+        // move under the drag instead of snapping to the 0.5 s fine grid.
+        let editing = isResizingSource(clip)
+        if editing {
+            let pad = max(2, (srcHi - srcLo) * 0.75)
+            MediaPipeline.shared.requestEditFineWindow(for: media, from: srcLo - pad, to: srcHi + pad)
+        }
         var x = rect.minX + floor((visX0 - rect.minX) / thumbW) * thumbW
         while x < visX1 {
             let tlSec = secondsFor(x + thumbW / 2)
             let srcSec = clip.sourceTime(at: tlSec)
-            if let img = MediaPipeline.shared.filmstripImage(for: media, at: max(0, srcSec)) {
+            var img: CGImage? = editing
+                ? MediaPipeline.shared.editFineImage(for: media, at: max(0, srcSec)) : nil
+            if img == nil, useFine { img = MediaPipeline.shared.fineThumbImage(for: media, at: max(0, srcSec)) }
+            if img == nil { img = MediaPipeline.shared.filmstripImage(for: media, at: max(0, srcSec)) }
+            if let img {
                 if DrawProf.on { DrawProf.thumbHits += 1 }
                 // CGContext blit with a local flip (CGImages draw bottom-up;
                 // the view is flipped). The images are pre-converted to the
@@ -1516,33 +1861,78 @@ final class TimelineView: NSView {
 
     private func drawWaveform(_ clip: Clip, media: MediaItem, rect: NSRect, color: NSColor,
                               cullX0: CGFloat, cullX1: CGFloat) {
-        // Center line
+        // On screen right now → build its peaks ahead of off-screen media.
+        MediaPipeline.shared.prioritizeMedia(media)
+        // Faint center line always — also the fallback look before peaks land.
         color.withAlphaComponent(0.35).setFill()
         NSRect(x: rect.minX, y: rect.midY + 6, width: rect.width, height: 1).fill()
-        guard let img = MediaPipeline.shared.waveformImage(for: media), media.duration > 0
-        else { return }
-        // Draw only the visible span — a zoomed-in clip's full rect can be
-        // millions of points wide, and image draws at that size are slow even
-        // though it's all clipped away. CGImage has no source-rect draw, so
-        // map the FULL image through the source→dest transform and clip to
-        // the visible span: pixel-identical to a fractional source rect
-        // (cropping(to:) would round to whole source pixels), and Quartz only
-        // rasterizes the clipped part.
+        guard let peaks = MediaPipeline.shared.peaks(for: media),
+              let cg = NSGraphicsContext.current?.cgContext else { return }
         let visX0 = max(rect.minX, cullX0 - 2), visX1 = min(rect.maxX, cullX1 + 2)
-        guard visX1 > visX0, let cg = NSGraphicsContext.current?.cgContext else { return }
-        let imgW = CGFloat(img.width)
-        let fromX = CGFloat(clip.srcIn / media.duration) * imgW
-        let fromW = max(1, CGFloat(clip.duration / media.duration) * imgW)
+        guard visX1 > visX0 else { return }
         let dest = NSRect(x: rect.minX, y: rect.minY + 14,
                           width: rect.width, height: rect.height - 16)
-        let scaleX = dest.width / fromW
+        guard dest.height > 4 else { return }
+        let midY = dest.midY, halfH = dest.height / 2 * 0.95
+
+        // Pick the pyramid level giving ~1–2 buckets per pixel at this zoom
+        // (time-stretch aware), then aggregate that level's min/max per column.
+        // Sharp at any zoom from one file; shifts correctly under trim/slip
+        // because each column samples the clip's true source time.
+        let srcPerPx = Double(clip.speed) / Double(pxPerSecond)
+        let level = peaks.level(forSrcSecPerPixel: srcPerPx)
+        let lvl = peaks.levels[level]
+        let bucketDur = peaks.bucketDur(level)
+        let bc = lvl.count / 2
+        guard bc > 0 else { return }
+
+        // A filled min/max envelope: top edge left→right along maxima, bottom
+        // edge right→left along minima. The view is flipped (y grows down), so
+        // positive amplitude draws above the center line.
+        let path = CGMutablePath()
+        var bottom: [CGPoint] = []
+        var started = false
+        var x = floor(visX0)
+        let xEnd = ceil(visX1)
+        while x <= xEnd {
+            let sA = clip.sourceTime(at: secondsFor(x))
+            let sB = clip.sourceTime(at: secondsFor(x + 1))
+            var b0 = Int(min(sA, sB) / bucketDur)
+            var b1 = Int(max(sA, sB) / bucketDur)
+            b0 = max(0, b0); b1 = min(bc - 1, b1)
+            if b0 <= b1 {
+                var mn = Int8(127), mx = Int8(-128)
+                var b = b0
+                while b <= b1 {
+                    let lo = lvl[2 * b], hi = lvl[2 * b + 1]
+                    if lo < mn { mn = lo }
+                    if hi > mx { mx = hi }
+                    b += 1
+                }
+                let px = x + 0.5
+                let yTop = midY - CGFloat(mx) / 127 * halfH
+                let yBot = midY - CGFloat(mn) / 127 * halfH
+                if !started { path.move(to: CGPoint(x: px, y: yTop)); started = true }
+                else { path.addLine(to: CGPoint(x: px, y: yTop)) }
+                bottom.append(CGPoint(x: px, y: yBot))
+            }
+            x += 1
+        }
+        guard started else { return }
+        for pt in bottom.reversed() { path.addLine(to: pt) }
+        path.closeSubpath()
         cg.saveGState()
-        cg.setAlpha(0.85)
-        cg.clip(to: CGRect(x: visX0, y: dest.minY, width: visX1 - visX0,
-                           height: dest.height))
-        cg.translateBy(x: dest.minX - fromX * scaleX, y: dest.maxY)
-        cg.scaleBy(x: 1, y: -1)
-        cg.draw(img, in: CGRect(x: 0, y: 0, width: imgW * scaleX, height: dest.height))
+        // NO antialiasing, deliberately. CoreGraphics' antialiased rasterizer
+        // corrupts large path fills when several bitmap contexts fill
+        // concurrently (the parallel cold-frame lane renders): envelope tips
+        // grew dark notches and speckles of OTHER lanes' colors — one frame of
+        // "waveform corruption" on every zoom change. Aliased fills never race,
+        // and the envelope is per-pixel columns anyway, so AA added nothing.
+        // Repro harness: --snappinch (draws every zoom frame twice and diffs).
+        cg.setShouldAntialias(false)
+        cg.addPath(path)
+        cg.setFillColor(color.withAlphaComponent(0.85).cgColor)
+        cg.fillPath()
         cg.restoreGState()
     }
 
@@ -1697,6 +2087,13 @@ final class TimelineView: NSView {
         let ncols = Int((bounds.width - headerW) / colW) + 1
         guard ncols > 0 else { return }
         var vals = [UInt8](repeating: .max, count: ncols)
+        // RAM-frame residency per column: 0 = no video clip there, 1 = every
+        // visible clip has a full-tier decoded frame in the RAM cache, 2 =
+        // every clip has one but some came from a reduced-tier source, 3 = at
+        // least one clip has none. Only all-resident columns (1/2) draw green
+        // — that is the condition under which a seek there flashes no
+        // stand-in; the dark variant flags the reduced tier.
+        var ram = [UInt8](repeating: 0, count: ncols)
         let leftSec = secondsFor(headerW), rightSec = secondsFor(bounds.width)
         var snaps: [String: ChunkManager.StripSnapshot?] = [:]
 
@@ -1717,6 +2114,20 @@ final class TimelineView: NSView {
                       media.duration > 0 else { continue }
                 let a = max(clip.start, leftSec), b = min(clip.end, rightSec)
                 guard b > a else { continue }
+                let rc0 = max(0, Int((xFor(a) - headerW) / colW))
+                let rc1 = min(ncols - 1, Int((xFor(b) - headerW) / colW))
+                if rc1 >= rc0 {
+                    for c in rc0...rc1 where ram[c] != 3 {
+                        let t = secondsFor(headerW + (CGFloat(c) + 0.5) * colW)
+                        let src = clip.srcIn + (t - clip.start) * clip.speed
+                        switch FrameCache.shared.residentQuality(mediaKey: media.cacheKey,
+                                                                 at: src) {
+                        case nil: ram[c] = 3
+                        case false?: ram[c] = 2
+                        case true?: if ram[c] == 0 { ram[c] = 1 }
+                        }
+                    }
+                }
                 let snap: ChunkManager.StripSnapshot?
                 if let cached = snaps[media.cacheKey] { snap = cached }
                 else { snap = ctx.chunks.stripSnapshot(media: media); snaps[media.cacheKey] = snap }
@@ -1759,6 +2170,21 @@ final class TimelineView: NSView {
             }
             c = e
         }
+
+        // RAM-resident runs paint over the disk (cyan) color (appended last):
+        // where the strip is green, a seek shows the exact frame with no
+        // stand-in — dark green when the frame came from a reduced source.
+        c = 0
+        while c < ncols {
+            let v = ram[c]
+            guard v == 1 || v == 2 else { c += 1; continue }
+            var e = c + 1
+            while e < ncols, ram[e] == v { e += 1 }
+            stripRuns.append((x: headerW + CGFloat(c) * colW,
+                              w: CGFloat(e - c) * colW,
+                              color: v == 1 ? Theme.stripRAM : Theme.stripRAMLow))
+            c = e
+        }
     }
 
     private func drawOptimizeStrip() {
@@ -1780,12 +2206,42 @@ final class TimelineView: NSView {
         Theme.rulerLine.setFill()
         NSRect(x: 0, y: rulerH - 1, width: bounds.width, height: 1).fill()
 
-        let steps: [Double] = [0.04, 0.1, 0.25, 0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600, 1800]
-        let major = steps.first { $0 * pxPerSecond >= 70 } ?? 3600
         let labelAttrs: [NSAttributedString.Key: Any] = [
             .font: NSFont.monospacedDigitSystemFont(ofSize: 9, weight: .regular),
             .foregroundColor: Theme.subtleLabel,
         ]
+
+        // Frame-grid regime: zoomed in far enough that a frame spans several
+        // pixels. Every tick lands on an ACTUAL frame boundary (k / fps) —
+        // exactly where the playhead quantizes to — so the ticks are the
+        // selectable frame grid, not arbitrary time fractions. Majors every N
+        // frames, labelled as HH:MM:SS:FF timecode.
+        let fd = frameDur
+        let frameW = fd * pxPerSecond
+        if frameW >= 5 {
+            let fpsI = max(1, Int(project.fps.rounded()))
+            let nfCands = [1, 2, 5, 10, 15, fpsI, fpsI * 2, fpsI * 5, fpsI * 10]
+            let majorFrames = max(1, nfCands.first { Double($0) * frameW >= 66 } ?? fpsI * 10)
+            var k = Int((originSecond / fd).rounded(.down))
+            while xFor(Double(k) * fd) < bounds.width {
+                let x = xFor(Double(k) * fd)
+                if x >= headerW, k >= 0 {
+                    let isMajor = k % majorFrames == 0
+                    (isMajor ? Theme.tickMajor : Theme.tickMinor).setFill()
+                    NSRect(x: x, y: rulerH - (isMajor ? 8 : 4), width: 1,
+                           height: isMajor ? 8 : 4).fill()
+                    if isMajor {
+                        timecodeString(frame: k, fps: project.fps)
+                            .draw(at: NSPoint(x: x + 3, y: 3), withAttributes: labelAttrs)
+                    }
+                }
+                k += 1
+            }
+            return
+        }
+
+        let steps: [Double] = [0.04, 0.1, 0.25, 0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600, 1800]
+        let major = steps.first { $0 * pxPerSecond >= 70 } ?? 3600
         var s = (originSecond / major).rounded(.down) * major
         while xFor(s) < bounds.width {
             let x = xFor(s)
@@ -1896,13 +2352,22 @@ final class TimelineView: NSView {
         .font: NSFont.systemFont(ofSize: 9, weight: .semibold),
         .foregroundColor: NSColor.white,
     ]
+    private static let todoMarkerLabelAttrs: [NSAttributedString.Key: Any] = [
+        .font: NSFont.systemFont(ofSize: 9, weight: .semibold),
+        .foregroundColor: NSColor.black,
+    ]
+    /// A marker whose label contains "TODO" flags outstanding work — it draws
+    /// yellow instead of blue so it reads at a glance.
+    private static func isTodo(_ m: Marker) -> Bool { m.label.contains("TODO") }
 
     /// Blue markers: a thin line down the lanes plus a clickable flag in the
     /// ruler. A named marker carries its name inside the flag itself; an
-    /// unnamed one gets a small plain pennant. Drawn under the red playhead.
+    /// unnamed one gets a small plain pennant. TODO markers draw yellow.
+    /// Drawn under the red playhead.
     private func drawMarkers() {
-        let blue = NSColor.systemBlue
         for m in project.sortedMarkers {
+            let todo = Self.isTodo(m)
+            let tint = todo ? NSColor.systemYellow : NSColor.systemBlue
             let x = xFor(m.time)
             guard x >= headerW, x <= bounds.width else { continue }
             // Flag hanging off the pole: a straight left edge on the pole and a
@@ -1912,9 +2377,9 @@ final class TimelineView: NSView {
             let top = rulerH - h - 1
             // Pole: a faint line down the lanes, plus a solid stem only as tall
             // as the flag (not running up to the top of the ruler).
-            blue.withAlphaComponent(0.5).setFill()
+            tint.withAlphaComponent(0.5).setFill()
             NSRect(x: x, y: rulerH, width: 1, height: bounds.height - rulerH).fill()
-            blue.withAlphaComponent(0.95).setFill()
+            tint.withAlphaComponent(0.95).setFill()
             NSRect(x: x, y: top, width: 1, height: rulerH - top).fill()
             let beak: CGFloat = 6
             let body: CGFloat = m.label.isEmpty
@@ -1930,7 +2395,8 @@ final class TimelineView: NSView {
             flag.fill()
             if !m.label.isEmpty {
                 (m.label as NSString).draw(at: NSPoint(x: x + 6, y: top + 2),
-                                           withAttributes: Self.markerLabelAttrs)
+                                           withAttributes: todo ? Self.todoMarkerLabelAttrs
+                                                                : Self.markerLabelAttrs)
             }
         }
     }
@@ -1938,11 +2404,13 @@ final class TimelineView: NSView {
     /// Hit region for a marker's ruler flag (click to seek, double-click to
     /// rename, right-click for its menu).
     private func markerHandleRect(_ m: Marker) -> NSRect {
-        // Cover the whole flag: pole + body + beak (see drawMarkers).
+        // Cover the flag itself: stem + body + beak (see drawMarkers: h=13,
+        // top = rulerH-14). The empty ruler strip ABOVE the flag deliberately
+        // stays scrub territory — that's why the flag isn't full height.
         let w: CGFloat = m.label.isEmpty
             ? 20
             : (m.label as NSString).size(withAttributes: Self.markerLabelAttrs).width + 21
-        return NSRect(x: xFor(m.time) - 4, y: 0, width: w, height: rulerH)
+        return NSRect(x: xFor(m.time) - 4, y: rulerH - 14, width: w, height: 14)
     }
     /// Topmost marker flag under a ruler point, if any.
     private func markerAt(point p: NSPoint) -> Marker? {
@@ -1957,6 +2425,39 @@ final class TimelineView: NSView {
         NSRect(x: x, y: 0, width: 1, height: bounds.height).fill()
     }
 
+    /// Ghost line at the edge's original position + a floating delta pill near
+    /// the cursor, so a trim/slip/ripple/stretch shows exactly how far it moved
+    /// against the clip thumbnails.
+    private func drawDragReadout() {
+        if let ox = dragOriginX, ox > headerW - 1, ox < bounds.width + 1 {
+            let line = NSBezierPath()
+            line.move(to: NSPoint(x: ox, y: lanesTop))
+            line.line(to: NSPoint(x: ox, y: bounds.height))
+            line.lineWidth = 1
+            line.setLineDash([4, 3], count: 2, phase: 0)
+            NSColor.white.withAlphaComponent(0.7).setStroke()
+            line.stroke()
+        }
+        guard let text = dragReadout else { return }
+        let attrs: [NSAttributedString.Key: Any] = [
+            .font: NSFont.monospacedDigitSystemFont(ofSize: 11, weight: .semibold),
+            .foregroundColor: NSColor.white,
+        ]
+        let size = text.size(withAttributes: attrs)
+        // Follow the cursor, biased above it; clamp inside the view.
+        var ox = lastMousePoint.x + 14
+        var oy = lastMousePoint.y - size.height - 12
+        ox = min(max(headerW + 4, ox), bounds.width - size.width - 10)
+        oy = min(max(lanesTop + 4, oy), bounds.height - size.height - 8)
+        let pill = NSRect(x: ox - 5, y: oy - 3, width: size.width + 10, height: size.height + 6)
+        let bg = NSBezierPath(roundedRect: pill, xRadius: 4, yRadius: 4)
+        NSColor.black.withAlphaComponent(0.8).setFill()
+        bg.fill()
+        NSColor.white.withAlphaComponent(0.25).setStroke()
+        bg.lineWidth = 1; bg.stroke()
+        text.draw(at: NSPoint(x: ox, y: oy), withAttributes: attrs)
+    }
+
     private func drawBoxSelect() {
         guard drag.mode == .box, drag.moved else { return }
         let r = boxRect()
@@ -1978,8 +2479,8 @@ final class TimelineView: NSView {
     // MARK: - Mouse editing
 
     private enum DragMode {
-        case none, scrub, move, trimIn, trimOut, rippleOut, rippleIn, slip,
-             stretchIn, stretchOut, fadeIn, fadeOut, box, resizeTrack,
+        case none, scrub, move, moveMarker, trimIn, trimOut, rippleOut, rippleIn, slip,
+             roll, stretchIn, stretchOut, fadeIn, fadeOut, box, resizeTrack,
              hBarPan, hBarLeft, hBarRight, vBarPan, vBarTop, vBarBottom
     }
 
@@ -2004,6 +2505,24 @@ final class TimelineView: NSView {
         var resizeOrigH: CGFloat = 0
         var moved = false
         var collapseTo: UUID?    // click-on-selected: reduce to this clip if no drag
+        var markerId: UUID?      // moveMarker: the dragged flag
+        var origMarkerTime = 0.0
+        // Roll: the two clips sharing the grabbed boundary and its pre-drag
+        // time. Deliberately NOT link-expanded — rolling just this lane's cut
+        // while its linked video stays put is what makes a J/L cut.
+        var rollLeftId: UUID?
+        var rollRightId: UUID?
+        var rollBoundary = 0.0
+        // ⌘-drag duplicate: the originals stay put and fresh copies take the
+        // move. Ids are minted once per gesture (updateGesture rebuilds from
+        // the base model each tick, so stable ids keep selection/players calm).
+        var duplicate = false
+        var dupIds: [UUID: UUID] = [:]       // orig clip id → clone id
+        var dupLinkIds: [UUID: UUID] = [:]   // orig linkId → clone linkId
+        var dupBoards: [UUID: Board] = [:]   // orig clip id → duplicated board
+        /// An audio clip hovering over a reaper lane: not a move — an
+        /// export-into-sidecar intent, resolved on mouse-up (bake + append).
+        var reaperDrop: (lane: Int, start: Double)?
     }
     private var drag = DragState()
 
@@ -2020,6 +2539,23 @@ final class TimelineView: NSView {
     private var activeSnapTarget: Double?
     private var dragHintRow: Int?
     private var lastMousePoint = NSPoint.zero
+    /// Live offset readout shown during trim/slip/ripple/stretch drags — the
+    /// text ("+0.40s · +12f") and the timeline x of the edge's ORIGINAL position
+    /// (a dashed ghost line, so the shift is visible against the thumbnails).
+    private var dragReadout: String?
+    private var dragOriginX: CGFloat?
+
+    /// Signed "+0.40s · +12f" for a seconds delta, prefixed with a verb.
+    private func offsetText(_ verb: String, _ seconds: Double) -> String {
+        let frames = Int((seconds / frameDur).rounded())
+        return String(format: "%@  %+.2fs · %+df", verb, seconds, frames)
+    }
+    /// Record the readout for the current drag. `originEdge` is the pre-drag
+    /// timeline second of the moving edge (nil = no ghost line, e.g. slip).
+    private func setDragReadout(_ text: String, originEdge: Double?) {
+        dragReadout = text
+        dragOriginX = originEdge.map { xFor($0) }
+    }
 
     override func mouseDown(with event: NSEvent) {
         window?.makeFirstResponder(self)
@@ -2040,12 +2576,15 @@ final class TimelineView: NSView {
             return
         }
 
-        // A marker flag in the ruler: click parks the playhead on it. Rename
-        // via its right-click menu (name field is inline there). Checked
-        // before the scrub fallthrough.
+        // A marker flag in the ruler: drag slides it along the timeline; a
+        // click without a drag parks the playhead on it (committed on mouseUp
+        // so the two don't fight). Rename via its right-click menu (name field
+        // is inline there). Checked before the scrub fallthrough.
         if p.y < rulerH, let m = markerAt(point: p) {
-            playback.setRate(0)
-            playback.seek(to: m.time)
+            drag.mode = .moveMarker
+            drag.markerId = m.id
+            drag.origMarkerTime = m.time
+            store.beginGesture()
             return
         }
 
@@ -2072,32 +2611,53 @@ final class TimelineView: NSView {
         }
         if p.y < lanesTop { return }
 
-        // Track header buttons
-        if p.x < headerW, let row = rowAt(y: p.y), let ref = laneRef(row: row) {
-            let lane = laneRect(row: row)
-            guard lane.height >= Self.headerButtonsMinHeight else { return }   // buttons hidden
-            let rects = headerButtonRects(lane: lane)
-            if let c = rects.color, ref.videoIndex != nil, c.insetBy(dx: -2, dy: -2).contains(p) {
-                openHeaderColorPicker(videoIndex: ref.videoIndex!, swatchRect: c)
-            } else if p.y < lane.midY {
-                session.toggleHidden(ref)
-            } else {
-                session.toggleFocus(ref)
+        // The left header column: track-height resize (on a lane boundary) and
+        // the hide/focus/colour buttons. Resize lives here ONLY — dragging a
+        // boundary over the clips no longer resizes. The boundary check comes
+        // first so a drag right at a lane's bottom edge resizes rather than
+        // toggling the button that happens to sit near it.
+        if p.x < headerW {
+            if let row = trackBoundaryAt(y: p.y), let ref = laneRef(row: row) {
+                drag.mode = .resizeTrack
+                drag.resizeRow = row
+                drag.resizeOrigH = laneHeight(ref)
+                return
+            }
+            if let row = rowAt(y: p.y), let ref = laneRef(row: row) {
+                // Merged sidecar header: the collapse toggle is the only
+                // control (no hide/focus/colour on reaper lanes).
+                if ref.isReaper {
+                    if let r = reaperCollapseRect, r.insetBy(dx: -5, dy: -5).contains(p) {
+                        session.reaperCollapsed.toggle()
+                        needsDisplay = true
+                    }
+                    return
+                }
+                let lane = laneRect(row: row)
+                guard lane.height >= Self.headerButtonsMinHeight else { return }   // buttons hidden
+                // Hit-test the buttons where they're actually DRAWN
+                // (headerButtonRects is the shared source of truth), padded a
+                // little for comfort — not the old crude midY split.
+                let rects = headerButtonRects(lane: lane)
+                let pad: CGFloat = 4
+                if let c = rects.color, ref.videoIndex != nil, c.insetBy(dx: -pad, dy: -pad).contains(p) {
+                    openHeaderColorPicker(videoIndex: ref.videoIndex!, swatchRect: c)
+                } else if rects.hide.insetBy(dx: -pad, dy: -pad).contains(p) {
+                    session.toggleHidden(ref)
+                } else if rects.focus.insetBy(dx: -pad, dy: -pad).contains(p) {
+                    session.toggleFocus(ref)
+                }
+                needsDisplay = true
             }
-            needsDisplay = true
-            return
-        }
-
-        // Track height resize on lane boundaries
-        if let row = trackBoundaryAt(y: p.y), let ref = laneRef(row: row) {
-            drag.mode = .resizeTrack
-            drag.resizeRow = row
-            drag.resizeOrigH = laneHeight(ref)
             return
         }
 
-        // Clicking a red overlap selects both offenders (S then resolves it).
-        if let o = overlapAt(point: p), clipAt(point: p) != nil {
+        // Clicking a red overlap selects both offenders (S then resolves it) —
+        // unless the click is on a resize handle, which must stay a trim (the
+        // edge-owning clip wins below) or fixing an overlap by trimming would
+        // be impossible.
+        if let o = overlapAt(point: p), clipAt(point: p) != nil,
+           edgeClipAt(point: p) == nil {
             store.selection = [o.a.id, o.b.id]
             drag.mode = .move
             drag.clipId = o.b.id
@@ -2108,13 +2668,14 @@ final class TimelineView: NSView {
             return
         }
 
-        guard let (clip, row) = clipAt(point: p) else {
+        guard let bodyHit = clipAt(point: p) else {
             // Empty area: box select (click without drag = deselect).
             drag.mode = .box
             drag.baseSelection = event.modifierFlags.contains(.shift) ? store.selection : []
             store.selection = drag.baseSelection
             return
         }
+        var (clip, row) = bodyHit
 
         if event.clickCount == 2, clip.kind == .storyboard {
             store.selection = [clip.id]
@@ -2122,8 +2683,20 @@ final class TimelineView: NSView {
             return
         }
 
+        // Double-clicking any green reaper clip opens the sidecar in REAPER.
+        if event.clickCount == 2, clip.track.isReaper {
+            store.selection = [clip.id]
+            ReaperLink.openInReaper(ctx)
+            return
+        }
+
         // Blade tool: click a clip to split it right there.
         if session.mainTool == .blade {
+            guard !clip.track.isReaper else {
+                NotificationCenter.default.post(name: .transientStatus, object: nil,
+                    userInfo: ["text": "REAPER clips are edited in REAPER — double-click to open"])
+                return
+            }
             store.selection = [clip.id]
             bladeAtPlayhead(at: quantize(secondsFor(p.x)),
                             ids: [clip.id],
@@ -2131,6 +2704,19 @@ final class TimelineView: NSView {
             return
         }
 
+        // A resize handle beats body stacking: when the point sits in an edge
+        // zone, the clip OWNING that edge takes the grab — inside an overlap
+        // the top clip's body otherwise hijacks the other clip's handle. And
+        // an edge grab inside an overlap targets JUST that clip (both
+        // offenders are often selected from an earlier overlap-click, which
+        // made every trim "resize both").
+        if let eHit = edgeClipAt(point: p) {
+            if overlapAt(point: p) != nil, !event.modifierFlags.contains(.shift) {
+                store.selection = [eHit.clip.id]
+            }
+            if eHit.clip.id != clip.id { (clip, row) = eHit }
+        }
+
         // Selection
         if event.modifierFlags.contains(.shift) {
             if store.selection.contains(clip.id) { store.selection.remove(clip.id) }
@@ -2162,23 +2748,63 @@ final class TimelineView: NSView {
         if drag.mode == .none {
             let stretch = event.modifierFlags.contains(.command) && clip.kind == .video
             let opt = event.modifierFlags.contains(.option)
+            let shift = event.modifierFlags.contains(.shift)
             let onIn = p.x - rect.minX < edge
             let onOut = rect.maxX - p.x < edge
+            // A plain drag on a SHARED boundary (two clips butted together)
+            // rolls both edges — trim one side's tail and the other's head in
+            // lockstep, the J/L-cut gesture. ⇧ opts out to a one-sided trim
+            // (leaving a gap or overlap on purpose); ⌥ (ripple) and ⌘
+            // (stretch) keep their meanings.
+            func beginRoll(left: Clip, right: Clip, boundary: Double) {
+                drag.mode = .roll
+                drag.rollLeftId = left.id
+                drag.rollRightId = right.id
+                drag.rollBoundary = boundary
+            }
             if opt, onOut {
                 drag.mode = .rippleOut   // ⌥-drag out edge: ripple the tail away
             } else if opt, onIn, clip.kind != .storyboard {
                 drag.mode = .rippleIn    // ⌥-drag in edge: ripple-trim the head
-            } else if opt || session.mainTool == .slide {
+            } else if opt || session.mainTool == .slip {
                 drag.mode = .slip        // ⌥-drag body: slip source under the clip
             } else if onIn {
-                drag.mode = stretch ? .stretchIn : .trimIn
+                if !stretch, !shift, let mate = rollMate(of: clip, before: true) {
+                    beginRoll(left: mate, right: clip, boundary: clip.start)
+                } else {
+                    drag.mode = stretch ? .stretchIn : .trimIn
+                }
             } else if onOut {
-                drag.mode = stretch ? .stretchOut : .trimOut
+                if !stretch, !shift, let mate = rollMate(of: clip, before: false) {
+                    beginRoll(left: clip, right: mate, boundary: clip.end)
+                } else {
+                    drag.mode = stretch ? .stretchOut : .trimOut
+                }
             } else {
                 drag.mode = .move
+                // ⌘ only means stretch on the edges, so ⌘-body-drag is free:
+                // it moves fresh COPIES and leaves the originals in place.
+                drag.duplicate = event.modifierFlags.contains(.command)
             }
         }
 
+        // Reaper lanes mirror the .rpp, and position is the only property the
+        // sequencer may edit — every grab is a whole-clip move, no trims, no
+        // slips, no fades, no ⌘-dup. And only while REAPER is closed: that's
+        // the guarantee there are no pending edits on the other side.
+        if clip.track.isReaper {
+            if ReaperLink.reaperRunning {
+                NSSound.beep()
+                NotificationCenter.default.post(name: .transientStatus, object: nil,
+                    userInfo: ["text": "REAPER is open — close it to move clips on REAPER lanes"])
+                drag = DragState()
+                needsDisplay = true
+                return
+            }
+            drag.mode = .move
+            drag.duplicate = false
+        }
+
         // Storyboard panels are start-only: clicking one parks the playhead on
         // it, and the body can't be dragged — only the edges (and nudges) move
         // the start. Everything else still works (blade, trims, ripple).
@@ -2197,10 +2823,17 @@ final class TimelineView: NSView {
         // Moves and edge trims carry the whole selection + link-mates: dragging
         // one edge resizes every selected/linked clip by the same amount.
         // (Slip/stretch/fade read drag.origClip only, so a wider set is inert.)
-        var editSet = project.expandLinks(store.selection)
-        editSet.insert(clip.id)
-        drag.origSelection = Dictionary(uniqueKeysWithValues:
-            project.clips.filter { editSet.contains($0.id) }.map { ($0.id, $0) })
+        // Roll deliberately touches ONLY its two boundary clips.
+        if drag.mode == .roll {
+            drag.origSelection = Dictionary(uniqueKeysWithValues:
+                project.clips.filter { $0.id == drag.rollLeftId || $0.id == drag.rollRightId }
+                    .map { ($0.id, $0) })
+        } else {
+            var editSet = project.expandLinks(store.selection)
+            editSet.insert(clip.id)
+            drag.origSelection = Dictionary(uniqueKeysWithValues:
+                project.clips.filter { editSet.contains($0.id) }.map { ($0.id, $0) })
+        }
         store.beginGesture()
     }
 
@@ -2210,11 +2843,14 @@ final class TimelineView: NSView {
         let dSec = Double(p.x - drag.startPoint.x) / pxPerSecond
         activeSnapTarget = nil
         dragHintRow = nil
+        dragReadout = nil
+        dragOriginX = nil
+        drag.reaperDrop = nil
 
         // Dragging against the view edges pans the timeline (there's no
         // enclosing scroll view, so the playhead could never leave the screen).
-        if [.scrub, .move, .trimIn, .trimOut, .rippleOut, .rippleIn, .slip,
-            .stretchIn, .stretchOut, .fadeIn, .fadeOut].contains(drag.mode) {
+        if [.scrub, .move, .moveMarker, .trimIn, .trimOut, .rippleOut, .rippleIn,
+            .slip, .roll, .stretchIn, .stretchOut, .fadeIn, .fadeOut].contains(drag.mode) {
             if p.x > bounds.width - 30 {
                 originSecond += Double(p.x - (bounds.width - 30)) * 0.12 / pxPerSecond
             } else if p.x < headerW + 20 {
@@ -2228,11 +2864,13 @@ final class TimelineView: NSView {
         case .scrub:
             playback.seek(to: max(0, quantize(secondsFor(p.x))))
         case .move: dragMove(p: p, dSec: dSec)
+        case .moveMarker: dragMarker(dSec: dSec)
         case .trimIn: dragTrimIn(dSec: dSec)
         case .trimOut: dragTrimOut(dSec: dSec)
         case .rippleOut: dragRippleOut(dSec: dSec)
         case .rippleIn: dragRippleIn(dSec: dSec)
         case .slip: dragSlip(dSec: dSec)
+        case .roll: dragRoll(dSec: dSec)
         case .stretchIn: dragStretch(dSec: dSec, fromStart: true)
         case .stretchOut: dragStretch(dSec: dSec, fromStart: false)
         case .fadeIn, .fadeOut: dragFade(p: p)
@@ -2298,10 +2936,39 @@ final class TimelineView: NSView {
     }
 
     override func mouseUp(with event: NSEvent) {
+        // Audio clip released over a reaper lane: not a move — bake its stem
+        // and append it to the sidecar project at the drop position.
+        if drag.mode == .move, let rd = drag.reaperDrop, let id = drag.clipId {
+            store.cancelGesture()
+            finishReaperDrop(clipId: id, lane: rd.lane, start: rd.start)
+            drag = DragState()
+            activeSnapTarget = nil
+            dragHintRow = nil
+            dragReadout = nil
+            dragOriginX = nil
+            needsDisplay = true
+            return
+        }
         switch drag.mode {
-        case .move, .trimIn, .trimOut, .rippleOut, .rippleIn, .slip,
+        case .move, .trimIn, .trimOut, .rippleOut, .rippleIn, .slip, .roll,
              .stretchIn, .stretchOut, .fadeIn, .fadeOut:
             store.endGesture()
+            // A committed move of sidecar clips owes the .rpp a write-back.
+            if drag.moved, drag.origSelection.values.contains(where: { $0.track.isReaper }) {
+                session.reaperDirty = true
+            }
+        case .moveMarker:
+            if drag.moved {
+                store.endGesture()
+            } else {
+                // A plain click on the flag still parks the playhead on it.
+                store.cancelGesture()
+                if let id = drag.markerId,
+                   let m = project.markers.first(where: { $0.id == id }) {
+                    playback.setRate(0)
+                    playback.seek(to: m.time)
+                }
+            }
         default:
             break
         }
@@ -2311,6 +2978,8 @@ final class TimelineView: NSView {
         drag = DragState()
         activeSnapTarget = nil
         dragHintRow = nil
+        dragReadout = nil
+        dragOriginX = nil
         needsDisplay = true
     }
 
@@ -2342,23 +3011,49 @@ final class TimelineView: NSView {
 
     private func dragMove(p: NSPoint, dSec: Double) {
         guard let orig = drag.origClip else { return }
-        // Vertical retracking only for a lone unlinked clip.
         let multi = drag.origSelection.count > 1 || store.selection.count > 1
 
-        // Snap+quantize the moved start edge, then clamp to t >= 0 for all moved clips.
+        // ⌘-drag duplicate: mint the clone ids (and board copies — disk, so
+        // outside the mutate) once, on the first tick that actually drags.
+        if drag.duplicate, drag.dupIds.isEmpty {
+            for (id, c) in drag.origSelection {
+                drag.dupIds[id] = UUID()
+                if let l = c.linkId, drag.dupLinkIds[l] == nil {
+                    drag.dupLinkIds[l] = UUID()
+                }
+                if c.kind == .storyboard, let b = c.board {
+                    drag.dupBoards[id] = boards.duplicate(b)
+                }
+            }
+        }
+        // When duplicating, the movers are the clones — the stationary
+        // originals stay valid snap targets (drop a copy flush against its
+        // source); a plain move excludes the moving clips themselves.
+        let snapExclude = drag.duplicate ? Set(drag.dupIds.values)
+                                         : Set(drag.origSelection.keys)
+
+        // Snap+quantize the moved start edge, then clamp to t >= 0 for all
+        // moved clips. A drag of ONLY audio clips positions freely (sub-frame).
+        let allAudio = drag.origSelection.values.allSatisfy { $0.kind == .audio }
         let snappedStart = snapAndQuantize(orig.start + dSec,
-                                           excluding: Set(drag.origSelection.keys),
-                                           duration: orig.duration)
+                                           excluding: snapExclude,
+                                           duration: orig.duration,
+                                           quantized: !allAudio)
         var delta = snappedStart - orig.start
         let minStart = drag.origSelection.values.map(\.start).min() ?? 0
         if minStart + delta < 0 { delta = -minStart }
+        if orig.kind != .storyboard {
+            setDragReadout(offsetText("Move", delta), originEdge: orig.start)
+        }
 
-        // Vertical: retarget track of the grabbed clip only (single-clip
-        // drags). Rows resolve against the GESTURE BASE — the closure below
-        // rebuilds from it, so live-project indices (which may include ghost
-        // tracks added by an earlier update in this same drag) would be off.
+        // Vertical: a lone clip retargets freely; a multi/linked selection
+        // shifts as a rigid group. Rows resolve against the GESTURE BASE — the
+        // closure below rebuilds from it, so live-project indices (which may
+        // include ghost tracks added by an earlier update in this same drag)
+        // would be off.
         let baseModel = store.gestureBaseModel ?? project
         let isPanel = orig.kind == .storyboard
+        let origIsReaper = orig.track.isReaper
         var targetRef: TrackRef? = nil
         var neededNewTracks = 0
         var groupRowDelta = 0
@@ -2369,33 +3064,64 @@ final class TimelineView: NSView {
                 if row >= baseCount {
                     // Dragging N rows below the last lane creates N tracks at
                     // once; the clip lands on the deepest one. Storyboard panels
-                    // stay on THE storyboard track.
-                    if !isPanel {
+                    // stay on THE storyboard track; reaper clips stay on the
+                    // sidecar lanes.
+                    if !isPanel, !origIsReaper {
                         neededNewTracks = min(8, row - baseCount + 1)
                         dragHintRow = row
                     }
                 } else {
-                    // Storyboard panels are isolated to the storyboard lane and
-                    // other clips stay off it.
                     let target = rows[row]
-                    if (target == .storyboard) == isPanel {
+                    if target.isReaper || origIsReaper {
+                        // Reaper clips move among reaper lanes; nothing else
+                        // lands there by plain move. An AUDIO clip dragged onto
+                        // a reaper lane is an export intent — bake + append on
+                        // drop. Video clips just don't take (they snap back).
+                        if origIsReaper, target.isReaper {
+                            targetRef = target
+                        } else if !origIsReaper, target.isReaper,
+                                  orig.kind == .audio, !drag.duplicate,
+                                  !ReaperLink.reaperRunning,
+                                  let lane = target.reaperIndex {
+                            drag.reaperDrop = (lane, max(0, orig.start + delta))
+                        }
+                    } else if (target == .storyboard) == isPanel {
+                        // Storyboard panels are isolated to the storyboard lane
+                        // and other clips stay off it.
                         targetRef = target
                     }
                 }
-            } else if row < baseCount, let origRow = baseModel.row(of: orig.track) {
+            } else if let origRow = baseModel.row(of: orig.track) {
                 // Vertical GROUP move: the whole selection (link groups
-                // included) shifts by the same number of rows, when every
-                // destination row exists and is a plain video track.
+                // included) shifts by the same number of rows. Every
+                // destination row must be a plain video track — and rows past
+                // the bottom qualify by BECOMING tracks, so a multi-clip or
+                // linked drag can grow the timeline downward just like a
+                // single-clip drag (same 8-lane cap).
                 let rowDelta = row - origRow
                 if rowDelta != 0 {
-                    let ok = drag.origSelection.values.allSatisfy { c in
+                    var deepest = -1
+                    var ok = true
+                    for c in drag.origSelection.values {
                         guard c.kind != .storyboard,
+                              !c.track.isReaper,   // sidecar clips never group-shift lanes
                               let r = baseModel.row(of: c.track),
-                              r + rowDelta >= 0, r + rowDelta < baseCount
-                        else { return false }
-                        return rows[r + rowDelta].videoIndex != nil
+                              r + rowDelta >= 0
+                        else { ok = false; break }
+                        let nr = r + rowDelta
+                        if nr < baseCount, rows[nr].videoIndex == nil {
+                            ok = false; break
+                        }
+                        deepest = max(deepest, nr)
+                    }
+                    if deepest >= baseCount + 8 { ok = false }
+                    if ok {
+                        groupRowDelta = rowDelta
+                        if deepest >= baseCount {
+                            neededNewTracks = deepest - baseCount + 1
+                            dragHintRow = deepest
+                        }
                     }
-                    if ok { groupRowDelta = rowDelta }
                 }
             }
         }
@@ -2406,15 +3132,40 @@ final class TimelineView: NSView {
                  "new=\(neededNewTracks) delta=\(delta)\n").utf8))
         }
 
+        let dup = drag.duplicate
+        let dupIds = drag.dupIds
+        let dupLinkIds = drag.dupLinkIds
+        let dupBoards = drag.dupBoards
+        // The ids that actually move: the clones when duplicating, else the
+        // grabbed selection itself.
+        let mover: (UUID) -> UUID = { dup ? (dupIds[$0] ?? $0) : $0 }
         store.updateGesture { model in
+            if dup {
+                // Originals stay put; copies (paste's id/link remap recipe)
+                // are appended at the source position and take the move below.
+                for (id, o) in drag.origSelection {
+                    var c = o
+                    c.id = dupIds[id] ?? UUID()
+                    if let l = c.linkId { c.linkId = dupLinkIds[l] }
+                    if let b = dupBoards[id] { c.board = b }
+                    model.clips.append(c)
+                }
+            }
             for (id, o) in drag.origSelection {
-                guard let i = model.clips.firstIndex(where: { $0.id == id }) else { continue }
+                guard let i = model.clips.firstIndex(where: { $0.id == mover(id) })
+                else { continue }
                 model.clips[i].start = o.start + delta
             }
+            // New lanes first, so group row targets below the old bottom exist.
+            // Indices are deterministic, so appending N lanes needs no stable
+            // identities.
+            if neededNewTracks > 0 {
+                for _ in 0..<neededNewTracks { model.addTrack() }
+            }
             if groupRowDelta != 0 {
                 let rows = model.laneRefs
                 for (id, o) in drag.origSelection {
-                    guard let i = model.clips.firstIndex(where: { $0.id == id }),
+                    guard let i = model.clips.firstIndex(where: { $0.id == mover(id) }),
                           let r = model.row(of: o.track)
                     else { continue }
                     let nr = r + groupRowDelta
@@ -2422,19 +3173,58 @@ final class TimelineView: NSView {
                         model.clips[i].track = rows[nr]
                     }
                 }
+            } else if let grabbed = drag.clipId,
+                      let i = model.clips.firstIndex(where: { $0.id == mover(grabbed) }) {
+                if neededNewTracks > 0 {
+                    // Single-clip drag below the bottom: land on the deepest new lane.
+                    model.clips[i].track = .video(model.tracks.count - 1)
+                } else if let ref = targetRef {
+                    model.clips[i].track = ref
+                }
             }
-            guard let i = model.clips.firstIndex(where: { $0.id == drag.clipId }) else { return }
-            if neededNewTracks > 0 {
-                // Indices are deterministic, so appending N lanes needs no
-                // stable identities — the clip lands on the deepest new one.
-                for _ in 0..<neededNewTracks { model.addTrack() }
-                model.clips[i].track = .video(model.tracks.count - 1)
-            } else if let ref = targetRef {
-                model.clips[i].track = ref
+        }
+        // The copies end up selected (like paste), not the untouched originals.
+        if dup {
+            let cloneIds = Set(dupIds.values)
+            if store.selection != cloneIds { store.selection = cloneIds }
+        }
+    }
+
+    /// Resolve a drop-export: one clip, one stem, appended to the `.rpp` and
+    /// migrated onto the chosen reaper lane at the drop position.
+    private func finishReaperDrop(clipId: UUID, lane: Int, start: Double) {
+        NotificationCenter.default.post(name: .transientStatus, object: nil,
+            userInfo: ["text": "Baking stem into the REAPER project…"])
+        ReaperExport.exportSingle(ctx: ctx, clipId: clipId,
+                                  toReaperIndex: lane, at: start) { result in
+            switch result {
+            case .success:
+                NotificationCenter.default.post(name: .transientStatus, object: nil,
+                    userInfo: ["text": "Added to the REAPER project"])
+            case .failure(let err):
+                let a = NSAlert()
+                a.messageText = "Couldn't add to the REAPER project"
+                a.informativeText = (err as? LocalizedError)?.errorDescription ?? "\(err)"
+                a.alertStyle = .warning
+                a.runModal()
             }
         }
     }
 
+    /// Slide a ruler marker along the timeline: snaps to clip edges and the
+    /// frame grid like a clip move, commits as one undo step on mouse-up.
+    private func dragMarker(dSec: Double) {
+        guard let id = drag.markerId else { return }
+        let t = max(0, snapAndQuantize(drag.origMarkerTime + dSec,
+                                       excluding: [], duration: 0))
+        setDragReadout(offsetText("Marker", t - drag.origMarkerTime),
+                       originEdge: drag.origMarkerTime)
+        store.updateGesture { model in
+            guard let i = model.markers.firstIndex(where: { $0.id == id }) else { return }
+            model.markers[i].time = t
+        }
+    }
+
     /// A trim/slip drag is exposing source material the clip didn't use
     /// before — tell the proxy builder NOW (mid-drag), not at mouse-up, so
     /// the newly extended range is often already covered when the user plays
@@ -2449,9 +3239,13 @@ final class TimelineView: NSView {
     /// dragging `orig`'s out-edge to `newEnd` (audio layers freely, so it
     /// never gets pushed).
     private func pushVictimsOut(orig: Clip, newEnd: Double, model: ProjectModel) -> [Clip] {
+        // Only clips the trim is reaching INTO: a neighbor whose head was
+        // already overlapped before the gesture is not a push victim — its
+        // handle-owner is being trimmed to RESOLVE that overlap, and dragging
+        // the neighbor's head along was the "resize both" trap.
         model.clips.filter {
             $0.id != orig.id && $0.track == orig.track && $0.kind != .audio
-                && $0.start >= orig.start && $0.start < newEnd && $0.end > orig.end - 1e-9
+                && $0.start >= orig.end - 1e-9 && $0.start < newEnd
         }
     }
 
@@ -2477,7 +3271,9 @@ final class TimelineView: NSView {
             return
         }
         let media = project.media(orig.mediaId)
-        let desired = snapAndQuantize(orig.end + dSec, excluding: [orig.id])
+        let allAudio = drag.origSelection.values.allSatisfy { $0.kind == .audio }
+        let desired = snapAndQuantize(orig.end + dSec, excluding: [orig.id],
+                                      quantized: !allAudio)
         var maxEnd = Double.greatestFiniteMagnitude
         if let media {
             maxEnd = orig.start + (media.duration - orig.srcIn) / max(0.001, orig.speed)
@@ -2496,6 +3292,7 @@ final class TimelineView: NSView {
             prefetchExposure(orig, sourceTime: orig.srcIn + (newEnd - orig.start) * orig.speed,
                              direction: 1)
         }
+        setDragReadout(offsetText("Trim", delta), originEdge: orig.end)
         let targets = drag.origSelection.values.filter { $0.kind != .storyboard }
         let single = targets.count <= 1
         store.updateGesture { model in
@@ -2522,7 +3319,9 @@ final class TimelineView: NSView {
 
     private func dragTrimIn(dSec: Double) {
         guard let orig = drag.origClip else { return }
-        let desired = snapAndQuantize(orig.start + dSec, excluding: [orig.id])
+        let allAudio = drag.origSelection.values.allSatisfy { $0.kind == .audio }
+        let desired = snapAndQuantize(orig.start + dSec, excluding: [orig.id],
+                                      quantized: !allAudio)
         // Storyboard panels are pure start positions (no source media), so the
         // in-edge just slides the panel's start either way — bounded only by the
         // previous panel (a frame of clearance) and this panel's own end.
@@ -2555,12 +3354,18 @@ final class TimelineView: NSView {
         // selected/linked clip. A storyboard in-edge just moves that panel's
         // start (normalization re-derives its duration).
         let delta = newStart - orig.start
+        setDragReadout(offsetText("Trim", delta), originEdge: orig.start)
         let targets = Array(drag.origSelection.values.filter { $0.kind != .storyboard })
         let single = targets.count <= 1
         // Trimming back through the previous clip trims its tail (single only).
+        // Same rule as pushVictimsOut: a clip already overlapping our head
+        // before the gesture isn't a victim — trimming the head is how that
+        // overlap gets RESOLVED, and eating the neighbor's tail too was the
+        // "resize both" trap.
         let victims = base.clips.filter {
             $0.id != orig.id && $0.track == orig.track && $0.kind != .audio
-                && $0.start < orig.start && $0.end > newStart
+                && $0.start < orig.start && $0.end <= orig.start + 1e-9
+                && $0.end > newStart
         }
         store.updateGesture { model in
             for t in targets {
@@ -2579,6 +3384,50 @@ final class TimelineView: NSView {
         }
     }
 
+    /// Drag the SHARED boundary of two adjacent clips: the left clip's tail
+    /// and the right clip's head move in lockstep (a roll edit), keeping the
+    /// join gapless. Clamped so each clip keeps at least a frame and neither
+    /// runs past its source. Not link-expanded — rolling one lane's cut while
+    /// its linked mates stay put is exactly how a J/L cut is made.
+    private func dragRoll(dSec: Double) {
+        guard let leftId = drag.rollLeftId, let rightId = drag.rollRightId else { return }
+        let base = store.gestureBaseModel ?? project
+        guard let left = base.clips.first(where: { $0.id == leftId }),
+              let right = base.clips.first(where: { $0.id == rightId }) else { return }
+        let bothAudio = left.kind == .audio && right.kind == .audio
+        let desired = snapAndQuantize(drag.rollBoundary + dSec,
+                                      excluding: [leftId, rightId],
+                                      quantized: !bothAudio)
+        var lo = left.start + frameDur
+        var hi = right.end - frameDur
+        if let m = base.media(left.mediaId) {   // left's tail source limit
+            hi = min(hi, left.start + (m.duration - left.srcIn) / max(0.001, left.speed))
+        }
+        // Right's head source limit (can't reveal before source 0).
+        lo = max(lo, right.start - right.srcIn / max(0.001, right.speed))
+        guard lo <= hi else { return }
+        let t = min(max(desired, lo), hi)
+        let delta = t - drag.rollBoundary
+        setDragReadout(offsetText("Roll", delta), originEdge: drag.rollBoundary)
+        if delta > 0 {   // left tail exposes fresh source
+            prefetchExposure(left, sourceTime: left.srcIn + (t - left.start) * left.speed,
+                             direction: 1)
+        } else if delta < 0 {   // right head exposes earlier source
+            prefetchExposure(right, sourceTime: right.srcIn + (t - right.start) * right.speed,
+                             direction: -1)
+        }
+        store.updateGesture { model in
+            if let i = model.clips.firstIndex(where: { $0.id == leftId }) {
+                model.clips[i].duration = t - left.start
+            }
+            if let j = model.clips.firstIndex(where: { $0.id == rightId }) {
+                model.clips[j].srcIn = right.srcIn + (t - right.start) * right.speed
+                model.clips[j].start = t
+                model.clips[j].duration = right.end - t
+            }
+        }
+    }
+
     /// ⌥-drag a clip's out edge: ripple resize. The edge trims/extends like a
     /// normal trim, and everything after it on the same track shifts by the
     /// same amount ("pushing the rest away"). On the storyboard track this
@@ -2586,31 +3435,66 @@ final class TimelineView: NSView {
     private func dragRippleOut(dSec: Double) {
         guard let orig = drag.origClip else { return }
         let base = store.gestureBaseModel ?? project
-        let desired = snapAndQuantize(orig.end + dSec, excluding: [orig.id])
-        var newEnd = max(desired, orig.start + frameDur)
-        if orig.kind == .video, let media = base.media(orig.mediaId) {
-            newEnd = min(newEnd, orig.start + (media.duration - orig.srcIn) / max(0.001, orig.speed))
+
+        // Storyboard panels: resize the panel's slot; later panels ride along.
+        // Panels are never linked, so this stays a single-track operation.
+        if orig.kind == .storyboard {
+            let desired = snapAndQuantize(orig.end + dSec, excluding: [orig.id])
+            let newEnd = max(desired, orig.start + frameDur)
+            let followers = base.clips.filter {
+                $0.id != orig.id && $0.track == orig.track && $0.start >= orig.end - 1e-9
+            }
+            let clampedDelta = max(newEnd - orig.end, -(followers.map(\.start).min() ?? 0))
+            store.updateGesture { model in
+                for f in followers {
+                    guard let j = model.clips.firstIndex(where: { $0.id == f.id }) else { continue }
+                    model.clips[j].start = f.start + clampedDelta
+                }
+            }
+            return
         }
-        let delta = newEnd - orig.end
-        let followers = base.clips.filter {
-            $0.id != orig.id && $0.track == orig.track && $0.start >= orig.end - 1e-9
+
+        // The grabbed clip's out-edge delta applies to every selected/linked
+        // clip, and each clip's OWN-track followers shift by it — so a multicam
+        // link ripples every angle and its track together. Followers are
+        // computed per target's track and excluded from the edit set.
+        let targets = Array(drag.origSelection.values.filter { $0.kind != .storyboard })
+        let editIds = Set(drag.origSelection.keys)
+        var followers: [UUID: Clip] = [:]
+        var lower = -Double.greatestFiniteMagnitude   // shrink limit (≥ one frame)
+        var upper = Double.greatestFiniteMagnitude    // extend limit (source end)
+        for t in targets {
+            lower = max(lower, frameDur - t.duration)
+            if t.kind == .video, let m = base.media(t.mediaId) {
+                upper = min(upper, (t.start + (m.duration - t.srcIn) / max(0.001, t.speed)) - t.end)
+            }
+            for f in base.clips where f.id != t.id && !editIds.contains(f.id)
+                && f.track == t.track && f.start >= t.end - 1e-9 {
+                followers[f.id] = f
+            }
         }
-        // Never push anything below t = 0.
-        let minStart = followers.map(\.start).min() ?? 0
-        let clampedDelta = max(delta, -minStart)
-        if clampedDelta > 0 {   // ripple-extending the tail exposes fresh source
+        if let minFollower = followers.values.map(\.start).min() {
+            lower = max(lower, -minFollower)   // followers never cross t = 0
+        }
+        // The moving edge snaps to STATIC references only — the edit set and its
+        // followers ride along, so they can't be snap targets.
+        var exclude = editIds; exclude.formUnion(followers.keys)
+        let desired = snapAndQuantize(orig.end + dSec, excluding: exclude)
+        let delta = min(max(desired - orig.end, lower), upper)
+        setDragReadout(offsetText("Ripple", delta), originEdge: orig.end)
+        if delta > 0 {   // ripple-extending the tail exposes fresh source
             prefetchExposure(orig,
-                             sourceTime: orig.srcIn + (orig.end + clampedDelta - orig.start) * orig.speed,
+                             sourceTime: orig.srcIn + (orig.end + delta - orig.start) * orig.speed,
                              direction: 1)
         }
         store.updateGesture { model in
-            if orig.kind != .storyboard,
-               let i = model.clips.firstIndex(where: { $0.id == orig.id }) {
-                model.clips[i].duration = (orig.end + clampedDelta) - orig.start
+            for t in targets {
+                guard let i = model.clips.firstIndex(where: { $0.id == t.id }) else { continue }
+                model.clips[i].duration = (t.end + delta) - t.start
             }
-            for f in followers {
-                guard let j = model.clips.firstIndex(where: { $0.id == f.id }) else { continue }
-                model.clips[j].start = f.start + clampedDelta
+            for (id, f) in followers {
+                guard let j = model.clips.firstIndex(where: { $0.id == id }) else { continue }
+                model.clips[j].start = f.start + delta
             }
         }
     }
@@ -2626,46 +3510,85 @@ final class TimelineView: NSView {
     private func dragRippleIn(dSec: Double) {
         guard let orig = drag.origClip, orig.kind != .storyboard else { return }
         let base = store.gestureBaseModel ?? project
-        let followers = base.clips.filter {
-            $0.id != orig.id && $0.track == orig.track && $0.start >= orig.end - 1e-9
+        // Like ripple-out, but the pinned edge is the head: the in-point and
+        // length change (the OUT edge stays put), and every clip's own-track
+        // followers pull in/out by the same amount. Applies to the whole
+        // selection + link-mates so a multicam group ripple-trims in sync.
+        let targets = Array(drag.origSelection.values.filter { $0.kind != .storyboard })
+        let editIds = Set(drag.origSelection.keys)
+        var followers: [UUID: Clip] = [:]
+        var lower = -Double.greatestFiniteMagnitude   // extend-head limit (source start)
+        var upper = Double.greatestFiniteMagnitude    // trim-head limit (≥ one frame)
+        for t in targets {
+            upper = min(upper, t.duration - frameDur)
+            lower = max(lower, -t.srcIn / max(0.001, t.speed))
+            for f in base.clips where f.id != t.id && !editIds.contains(f.id)
+                && f.track == t.track && f.start >= t.end - 1e-9 {
+                followers[f.id] = f
+            }
         }
-        // Snap the moving OUT edge to static references only — the followers ride
-        // along with it, so they can't be snap targets. d > 0 trims the head.
-        var exclude = Set(followers.map(\.id)); exclude.insert(orig.id)
+        if let minFollower = followers.values.map(\.start).min() {
+            upper = min(upper, minFollower)   // followers never cross t = 0
+        }
+        // Snap the moving OUT edge to static references only — the edit set and
+        // followers ride along. d > 0 trims the head.
+        var exclude = editIds; exclude.formUnion(followers.keys)
         let newEnd = snapAndQuantize(orig.end - dSec, excluding: exclude)
-        var d = orig.end - newEnd
-        d = min(d, orig.duration - frameDur)                    // keep ≥ one frame
-        d = max(d, -orig.srcIn / max(0.001, orig.speed))        // head ≥ source start
-        if let firstStart = followers.map(\.start).min() {       // followers ≥ t = 0
-            d = min(d, firstStart)
-        }
+        let d = min(max(orig.end - newEnd, lower), upper)
+        // The pinned edge is the head; the OUT edge moves by −d.
+        setDragReadout(offsetText("Ripple", -d), originEdge: orig.end)
         if d < 0 {   // ripple-extending the head exposes earlier source
             prefetchExposure(orig, sourceTime: orig.srcIn + d * orig.speed, direction: -1)
         }
         store.updateGesture { model in
-            guard let i = model.clips.firstIndex(where: { $0.id == orig.id }) else { return }
-            model.clips[i].srcIn = orig.srcIn + d * orig.speed
-            model.clips[i].duration = orig.duration - d
-            for f in followers {
-                guard let j = model.clips.firstIndex(where: { $0.id == f.id }) else { continue }
+            for t in targets {
+                guard let i = model.clips.firstIndex(where: { $0.id == t.id }) else { continue }
+                model.clips[i].srcIn = t.srcIn + d * t.speed
+                model.clips[i].duration = t.duration - d
+            }
+            for (id, f) in followers {
+                guard let j = model.clips.firstIndex(where: { $0.id == id }) else { continue }
                 model.clips[j].start = f.start - d
             }
         }
     }
 
     private func dragSlip(dSec: Double) {
-        guard let orig = drag.origClip, let media = project.media(orig.mediaId) else { return }
-        let maxIn = max(0, media.duration - orig.sourceLength)
-        let newIn = min(max(orig.srcIn - dSec * orig.speed, 0), maxIn)
-        // Slipping reveals source on the side the content is sliding from.
-        if newIn < orig.srcIn {
-            prefetchExposure(orig, sourceTime: newIn, direction: -1)
-        } else if newIn > orig.srcIn {
-            prefetchExposure(orig, sourceTime: newIn + orig.sourceLength, direction: 1)
+        guard let orig = drag.origClip, project.media(orig.mediaId) != nil else { return }
+        // Slip the whole selection + link-mates by the SAME timeline amount, so
+        // a multicam group's angles stay frame-locked. Each clip maps the slip
+        // into its own source (`srcIn -= slip·speed`); the shared slip is
+        // clamped to whatever range keeps EVERY clip inside its media, so no
+        // angle runs off the end of its source.
+        let targets = Array(drag.origSelection.values.filter {
+            $0.kind != .storyboard && $0.mediaId != nil
+        })
+        var lo = -Double.greatestFiniteMagnitude
+        var hi = Double.greatestFiniteMagnitude
+        for t in targets {
+            guard let m = project.media(t.mediaId) else { continue }
+            let maxIn = max(0, m.duration - t.sourceLength)
+            let sp = max(0.001, t.speed)
+            // newIn = t.srcIn − slip·sp ∈ [0, maxIn] ⇒ slip ∈ [(srcIn−maxIn)/sp, srcIn/sp]
+            lo = max(lo, (t.srcIn - maxIn) / sp)
+            hi = min(hi, t.srcIn / sp)
+        }
+        let slip = min(max(dSec, lo), hi)
+        // Prefetch the grabbed clip's newly revealed side.
+        let newInOrig = orig.srcIn - slip * orig.speed
+        // Slip shows the SOURCE offset (the thumbnails slide by this much); the
+        // clip's timeline edges don't move, so there's no ghost line.
+        setDragReadout(offsetText("Slip", newInOrig - orig.srcIn), originEdge: nil)
+        if newInOrig < orig.srcIn {
+            prefetchExposure(orig, sourceTime: newInOrig, direction: -1)
+        } else if newInOrig > orig.srcIn {
+            prefetchExposure(orig, sourceTime: newInOrig + orig.sourceLength, direction: 1)
         }
         store.updateGesture { model in
-            guard let i = model.clips.firstIndex(where: { $0.id == drag.clipId }) else { return }
-            model.clips[i].srcIn = newIn
+            for t in targets {
+                guard let i = model.clips.firstIndex(where: { $0.id == t.id }) else { continue }
+                model.clips[i].srcIn = t.srcIn - slip * t.speed
+            }
         }
     }
 
@@ -2687,12 +3610,34 @@ final class TimelineView: NSView {
         }
         newDur = min(max(newDur, srcLen / 50), srcLen * 50)
         if fromStart { newStart = orig.end - newDur }
-        let speed = srcLen / newDur
+        setDragReadout(String(format: "Stretch  ×%.3g · %+.2fs", srcLen / newDur,
+                              newDur - orig.duration),
+                       originEdge: fromStart ? orig.start : orig.end)
+        // The grabbed edge's movement becomes a shared delta applied to every
+        // selected/linked clip, keeping their SOURCE ranges fixed and adjusting
+        // each clip's own speed — so a stretched multicam group stays in sync
+        // (each angle keeps its own content but the shared cut length changes).
+        let startDelta = newStart - orig.start   // in-edge move (fromStart)
+        let endDelta = (newStart + newDur) - orig.end   // out-edge move
+        let targets = Array(drag.origSelection.values.filter { $0.kind != .storyboard })
         store.updateGesture { model in
-            guard let i = model.clips.firstIndex(where: { $0.id == drag.clipId }) else { return }
-            model.clips[i].start = newStart
-            model.clips[i].duration = newDur
-            model.clips[i].speed = speed
+            for t in targets {
+                guard let i = model.clips.firstIndex(where: { $0.id == t.id }) else { continue }
+                let sl = t.sourceLength
+                var ns = t.start
+                var nd: Double
+                if fromStart {
+                    ns = min(max(t.start + startDelta, 0), t.end - self.frameDur)
+                    nd = t.end - ns
+                } else {
+                    nd = max(self.frameDur, t.duration + endDelta)
+                }
+                nd = min(max(nd, sl / 50), sl * 50)
+                if fromStart { ns = t.end - nd }
+                model.clips[i].start = ns
+                model.clips[i].duration = nd
+                model.clips[i].speed = sl / nd
+            }
         }
     }
 
@@ -2715,13 +3660,17 @@ final class TimelineView: NSView {
     /// through here so trims, moves and ripples align identically (previously each
     /// re-implemented this, and the ripple handler quantized twice out of order).
     private func snapAndQuantize(_ desired: Double, excluding: Set<UUID>,
-                                 duration: Double = 0) -> Double {
+                                 duration: Double = 0, quantized: Bool = true) -> Double {
         var v = desired
         if let adj = snapAdjust(start: v, duration: duration, excluding: excluding) {
             v += adj.adjust
             activeSnapTarget = adj.target
         }
-        return quantize(v)
+        // Audio-only edits pass quantized:false — sound isn't bound to the
+        // frame grid (only the video/Fusion side is), and precise alignment
+        // (loop seams, sync-by-ear) needs sub-frame positions. Snapping to
+        // neighbours' edges above still applies either way.
+        return quantized ? quantize(v) : max(0, v)
     }
 
     private func snapAdjust(start: Double, duration: Double, excluding: Set<UUID>)
@@ -2781,10 +3730,12 @@ final class TimelineView: NSView {
             default: return .arrow
             }
         }
-        if trackBoundaryAt(y: p.y) != nil, p.y > lanesTop { return .resizeUpDown }
+        // Resize is a header-only gesture now, so its affordance shows only over
+        // the header column near a lane boundary.
+        if p.x < headerW, p.y > lanesTop, trackBoundaryAt(y: p.y) != nil { return .resizeUpDown }
         guard let (clip, row) = clipAt(point: p) else { return .arrow }
         if session.mainTool == .blade { return .crosshair }
-        if session.mainTool == .slide { return .openHand }
+        if session.mainTool == .slip { return .openHand }
         let rect = clipRect(clip, row: row)
         let onEdge = p.x - rect.minX < 7 || rect.maxX - p.x < 7
         if mods.contains(.option), !onEdge { return .openHand }   // ⌥ body: slip
@@ -2815,9 +3766,14 @@ final class TimelineView: NSView {
             if event.modifierFlags.contains(.option) { moveOverlapsToSeparateTracks() }
             else { pc.setOut() }
         case "c": pc.toggleLoop()
-        case "m":
-            if event.modifierFlags.contains(.option) { toggleMute() }
-            else { toggleMarkerAtPlayhead() }
+        case "m": toggleMarkerAtPlayhead()
+        case "p": toggleMute()
+        case "f" where event.modifierFlags.isDisjoint(with: [.command, .control, .option]):
+            toggleTrackVisibilityUnderMouse(focus: true,
+                                            shift: event.modifierFlags.contains(.shift))
+        case "h" where event.modifierFlags.isDisjoint(with: [.command, .control, .option]):
+            toggleTrackVisibilityUnderMouse(focus: false,
+                                            shift: event.modifierFlags.contains(.shift))
         case "v": session.mainTool = .select
         case "y": session.snapping.toggle()
         case "g":
@@ -2833,10 +3789,10 @@ final class TimelineView: NSView {
                 deleteSelection()
             }
         case "\\": rippleDelete()   // documented default ripple-delete key (also ⌥⌫)
-        case "a" where !event.modifierFlags.contains(.command):   // ripple trim left (also ⌥←)
-            rippleTrimToPlayhead(deleteLeft: true)
-        case "d" where !event.modifierFlags.contains(.command):   // ripple trim right (also ⌥→)
-            rippleTrimToPlayhead(deleteLeft: false)
+        case "a" where !event.modifierFlags.contains(.command):   // A ripple-trim left (also ⌥←), ⇧A delete-left
+            rippleTrimToPlayhead(deleteLeft: true, ripple: !event.modifierFlags.contains(.shift))
+        case "d" where !event.modifierFlags.contains(.command):   // D ripple-trim right (also ⌥→), ⇧D delete-right
+            rippleTrimToPlayhead(deleteLeft: false, ripple: !event.modifierFlags.contains(.shift))
         case "[":
             if event.modifierFlags.contains(.option) { goToPrevMarker() }
             else if event.modifierFlags.contains(.command) { goToPrevStoryboardPanel() }
@@ -2869,6 +3825,38 @@ final class TimelineView: NSView {
         }
     }
 
+    /// F / H act on the lane (or Fusion band) under the mouse — the timeline
+    /// counterpart to the viewer grid's hover shortcuts: F focus, ⇧F priority,
+    /// H hide, ⇧H show-all. Reaper lanes have no hide/focus control, so they're
+    /// skipped. Uses the live pointer position (the timeline has no hover
+    /// tracking), so it bites wherever the cursor sits when the key is pressed.
+    private func toggleTrackVisibilityUnderMouse(focus: Bool, shift: Bool) {
+        // ⇧H reveals everything — global, so it works even with nothing hovered
+        // (i.e. when every track is already hidden).
+        if !focus && shift { session.showAll(); needsDisplay = true; return }
+
+        let p = convert(window?.mouseLocationOutsideOfEventStream ?? .zero, from: nil)
+
+        // The Fusion band (header or lane) is the Fusion focus/hide target;
+        // it has no priority concept, so ⇧F is a no-op there.
+        if fusionBandH > 0, p.y > fusionTop, p.y < lanesTop {
+            if focus { if !shift { session.fusionFocus.toggle() } }
+            else { session.fusionHidden.toggle() }
+            needsDisplay = true
+            return
+        }
+
+        guard let row = rowAt(y: p.y), let ref = laneRef(row: row),
+              !ref.isReaper else { return }
+        if focus {
+            if shift { session.priorityPane = session.priorityPane == ref ? nil : ref }
+            else { session.toggleFocus(ref) }
+        } else {
+            session.toggleHidden(ref)
+        }
+        needsDisplay = true
+    }
+
     /// ←/→ nudge the selected clips by a frame (⇧ = 1 s); with nothing
     /// selected they move the playhead like [ and ].
     func nudgeSelection(by seconds: Double) {
@@ -2877,6 +3865,15 @@ final class TimelineView: NSView {
             playback.step(by: seconds)
             return
         }
+        // Nudge IS a move, so reaper clips take it — but only while REAPER is
+        // closed, same rule as dragging them.
+        let hasReaper = project.clips.contains { sel.contains($0.id) && $0.track.isReaper }
+        if hasReaper, ReaperLink.reaperRunning {
+            NotificationCenter.default.post(name: .transientStatus, object: nil,
+                userInfo: ["text": "REAPER is open — close it to move clips on REAPER lanes"])
+            return
+        }
+        if hasReaper { session.reaperDirty = true }
         store.mutate { model in
             let minStart = model.clips.filter { sel.contains($0.id) }.map(\.start).min() ?? 0
             let d = max(seconds, -minStart)
@@ -2892,6 +3889,15 @@ final class TimelineView: NSView {
         var ids = store.selection
         if ids.isEmpty, let (clip, _) = clipAt(point: lastMousePoint) { ids = [clip.id] }
         guard !ids.isEmpty else { return }
+        // Mute round-trips to the .rpp (push writes MUTE), so it follows the
+        // same REAPER-closed rule as moves.
+        let hasReaper = project.clips.contains { ids.contains($0.id) && $0.track.isReaper }
+        if hasReaper, ReaperLink.reaperRunning {
+            NotificationCenter.default.post(name: .transientStatus, object: nil,
+                userInfo: ["text": "REAPER is open — close it to edit REAPER lanes"])
+            return
+        }
+        if hasReaper { session.reaperDirty = true }
         store.mutate { model in
             let allMuted = model.clips.filter { ids.contains($0.id) }.allSatisfy(\.muted)
             for i in model.clips.indices where ids.contains(model.clips[i].id) {
@@ -3024,13 +4030,14 @@ final class TimelineView: NSView {
         let victims = project.clips.filter {
             ids.contains($0.id) && t > $0.start + frameDur / 2 && t < $0.end - frameDur / 2
                 && (!onlyStoryboards || $0.kind == .storyboard)
+                && !$0.track.isReaper   // splitting sidecar items happens in REAPER
         }
         guard !victims.isEmpty else { return }
         // When the split acted on an actual selection, both resulting halves
         // stay selected. (The blade tool passes explicitIds and leaves the
         // selection alone.)
         let reselect = explicitIds == nil && !store.selection.isEmpty
-        var newRightIds: [UUID] = []
+        var newLeftIds: [UUID] = []
         var rightLinkIds: [UUID: UUID] = [:]   // old linkId → new right-half linkId
         // Board copies happen OUTSIDE mutate (they touch disk).
         var rightBoards: [UUID: Board] = [:]
@@ -3040,9 +4047,12 @@ final class TimelineView: NSView {
         store.mutate { model in
             for v in victims {
                 guard let i = model.clips.firstIndex(where: { $0.id == v.id }) else { continue }
+                // The half AHEAD of the playhead keeps v.id: audio players are
+                // keyed by clip id and v.id's source mapping from t onward is
+                // unchanged, so a split during playback rides through on the
+                // already-warm player. The LEFT half takes the fresh id (its
+                // cold player idles at gain 0 — silent).
                 var right = v
-                right.id = UUID()
-                newRightIds.append(right.id)
                 right.start = t
                 right.srcIn = v.srcIn + (t - v.start) * v.speed
                 right.duration = v.end - t
@@ -3060,6 +4070,8 @@ final class TimelineView: NSView {
                     right.fadeIn = 0
                     right.fadeOut = min(v.fadeOut, right.duration)
                 }
+                model.clips[i].id = UUID()
+                newLeftIds.append(model.clips[i].id)
                 model.clips[i].duration = t - v.start
                 if v.kind == .audio {
                     model.clips[i].fadeOut = 0
@@ -3069,7 +4081,7 @@ final class TimelineView: NSView {
             }
         }
         if reselect {
-            store.selection = Set(victims.map(\.id)).union(newRightIds)
+            store.selection = Set(victims.map(\.id)).union(newLeftIds)
         }
     }
 
@@ -3136,7 +4148,8 @@ final class TimelineView: NSView {
 
     func deleteSelection() {
         // Deleting a linked clip deletes its whole link group.
-        let sel = project.expandLinks(store.selection)
+        var sel = project.expandLinks(store.selection)
+        excludeReaperClips(from: &sel)
         guard !sel.isEmpty else { return }
         store.mutate { model in
             model.clips.removeAll { sel.contains($0.id) }
@@ -3144,11 +4157,23 @@ final class TimelineView: NSView {
         }
     }
 
+    /// Reaper-lane clips can't be deleted here — the .rpp owns their
+    /// existence (a local delete would just resurrect on the next pull).
+    private func excludeReaperClips(from sel: inout Set<UUID>) {
+        let reaper = Set(project.clips.filter { sel.contains($0.id) && $0.track.isReaper }
+            .map(\.id))
+        guard !reaper.isEmpty else { return }
+        sel.subtract(reaper)
+        NotificationCenter.default.post(name: .transientStatus, object: nil,
+            userInfo: ["text": "REAPER clips are deleted in REAPER — double-click to open"])
+    }
+
     /// ⌥⌫ — ripple delete: remove the selection and close the time gap it
     /// occupied, shifting everything later (on ALL tracks, so multicam sync
     /// holds) left by the gap.
     func rippleDelete() {
-        let sel = project.expandLinks(store.selection)
+        var sel = project.expandLinks(store.selection)
+        excludeReaperClips(from: &sel)
         guard !sel.isEmpty else { return }
         let victims = project.clips.filter { sel.contains($0.id) }
         // Storyboard panels are start-only points; only solid clips define
@@ -3185,7 +4210,11 @@ final class TimelineView: NSView {
     /// side toward the arrow, closing the gap. With a selection it acts on the
     /// selected/linked clips the playhead crosses; with none, on every angle
     /// under the playhead (so multicam stays in sync).
-    func rippleTrimToPlayhead(deleteLeft: Bool) {
+    ///
+    /// `ripple == false` (⇧A / ⇧D, "Delete Left" / "Delete Right") trims the
+    /// same clips but leaves the freed span as a gap — nothing after it slides,
+    /// and the playhead never moves.
+    func rippleTrimToPlayhead(deleteLeft: Bool, ripple: Bool = true) {
         let t = quantize(playback.playhead)
         let eps = 1e-6
         let straddles: (Clip) -> Bool = {
@@ -3207,6 +4236,15 @@ final class TimelineView: NSView {
             let gap = gapEnd - gapStart
             guard gap > eps else { return }
             let ids = Set(crossing.map(\.id))
+            // Delete-left slides the kept content AND the playhead back by the
+            // same gap — every player stays on the same source frame, so the
+            // playhead re-anchors gaplessly (no hard resync; a seek here
+            // force-reseeks every audio player: an audible dropout for an edit
+            // that changed nothing audible). It happens BEFORE the mutate so
+            // the .projectChanged player sync sees playhead and model move as
+            // one. Delete-right pulls NEW content under the playhead, so its
+            // hard reseek below is the point.
+            if ripple, deleteLeft { playback.shiftBeforeEdit(by: -gap) }
             store.mutate { model in
                 for tgt in model.clips where ids.contains(tgt.id) {
                     guard let i = model.clips.firstIndex(where: { $0.id == tgt.id }) else { continue }
@@ -3219,16 +4257,19 @@ final class TimelineView: NSView {
                     }
                 }
                 // Close the gap on EVERY track (the kept right pieces start at
-                // gapEnd, so they ride left with everything else).
-                for i in model.clips.indices where model.clips[i].start >= gapEnd - 1e-9 {
-                    model.clips[i].start = max(0, model.clips[i].start - gap)
+                // gapEnd, so they ride left with everything else). Non-ripple
+                // leaves the freed span open.
+                if ripple {
+                    for i in model.clips.indices where model.clips[i].start >= gapEnd - 1e-9 {
+                        model.clips[i].start = max(0, model.clips[i].start - gap)
+                    }
                 }
                 model.pruneTrailingEmptyTracks()
             }
             // The kept piece keeps its id, so a trim that started from a
             // selection leaves that resulting clip selected.
             if hadSelection { store.selection = ids }
-            playback.seek(to: gapStart)
+            if ripple, !deleteLeft { playback.seek(to: gapStart) }
             return
         }
 
@@ -3245,14 +4286,20 @@ final class TimelineView: NSView {
         let gap = gapEnd - gapStart
         guard gap > eps else { return }
         let ids = Set(adjacent.map(\.id))
+        // Same reasoning as above: delete-left slides content with the
+        // playhead (gapless, re-anchored before the mutate); delete-right
+        // changes what's ahead (hard seek).
+        if ripple, deleteLeft { playback.shiftBeforeEdit(by: -gap) }
         store.mutate { model in
             model.clips.removeAll { ids.contains($0.id) }
-            for i in model.clips.indices where model.clips[i].start >= gapEnd - 1e-9 {
-                model.clips[i].start = max(0, model.clips[i].start - gap)
+            if ripple {
+                for i in model.clips.indices where model.clips[i].start >= gapEnd - 1e-9 {
+                    model.clips[i].start = max(0, model.clips[i].start - gap)
+                }
             }
             model.pruneTrailingEmptyTracks()
         }
-        playback.seek(to: gapStart)
+        if ripple, !deleteLeft { playback.seek(to: gapStart) }
     }
 
     /// The closeable blank column at a moment: nothing under it on any track,
@@ -3518,14 +4565,18 @@ final class TimelineView: NSView {
     /// (so the same key toggles). One undo step.
     func toggleMarkerAtPlayhead() {
         let t = quantize(playback.playhead)
+        var added: UUID?
         store.mutate { model in
             let half = 0.5 / max(1, model.fps)
             if let idx = model.markers.firstIndex(where: { abs($0.time - t) < half }) {
                 model.markers.remove(at: idx)
             } else {
-                model.markers.append(Marker(time: t))
+                let m = Marker(time: t)
+                added = m.id
+                model.markers.append(m)
             }
         }
+        if let id = added { placeDidAddMarker(id) }
     }
 
     /// ⌘] / ⌘[ — jump the playhead to the next/previous storyboard panel start.
@@ -3581,9 +4632,71 @@ final class TimelineView: NSView {
     private var ctxTrack: TrackRef?
     private var ctxCompPath: String?
     private var ctxMarkerId: UUID?
+    private var ctxRevealURL: URL?
     // The inline name field of the open marker menu, committed on menuDidClose.
     private weak var markerNameField: MarkerNameMenuField?
     private var markerNameOriginal = ""
+    // The inline volume slider of the open clip menu: previews live, commits
+    // one undo step (against volumeBaseModel) on menuDidClose.
+    private weak var volumeField: ClipVolumeMenuField?
+    private var volumeBaseModel: ProjectModel?
+    private var volumeTargets: Set<UUID> = []
+
+    /// The marker flag menu: inline name field (like Frame Rate, not a popup —
+    /// committed on menuDidClose so Return / click-away all persist) plus
+    /// delete/clear. Shared by right-click on a flag and the auto-open right
+    /// after placing one.
+    private func markerMenu(for m: Marker) -> NSMenu {
+        let menu = NSMenu()
+        ctxMarkerId = m.id
+        let nameField = MarkerNameMenuField(name: m.label)
+        nameField.onReturn = { [weak menu] in menu?.cancelTracking() }
+        nameField.onDeleteEmpty = { [weak self, weak menu] in
+            guard let self else { return }
+            self.markerNameField = nil   // nothing to commit — the marker is going away
+            menu?.cancelTracking()
+            self.deleteMarker(m.id)
+        }
+        markerNameField = nameField
+        markerNameOriginal = m.label
+        menu.delegate = self
+        let nameItem = NSMenuItem()
+        nameItem.view = nameField
+        menu.addItem(nameItem)
+        menu.addItem(.separator())
+        // ⌘⌫, not bare ⌫: the menu's key-equivalent matcher sees keystrokes
+        // before the focused name field does, so a plain backspace while
+        // typing must edit text, never delete the marker.
+        let del = NSMenuItem(title: "Delete Marker", action: #selector(ctxDeleteMarker),
+                             keyEquivalent: "\u{8}")
+        del.target = self
+        del.keyEquivalentModifierMask = [.command]
+        menu.addItem(del)
+        if !project.markers.isEmpty {
+            menu.addItem(.separator())
+            let clear = NSMenuItem(title: "Clear All Markers",
+                                   action: #selector(ctxClearMarkers), keyEquivalent: "")
+            clear.target = self
+            menu.addItem(clear)
+        }
+        return menu
+    }
+
+    /// Placing a marker pops its flag menu open with the name field focused:
+    /// type the name straight away, or just hit Return to keep it as is.
+    /// Skipped when the window isn't on screen (the headless uitest — menu
+    /// tracking would block forever).
+    private func placeDidAddMarker(_ id: UUID) {
+        guard window?.isVisible == true else { return }
+        DispatchQueue.main.async { [weak self] in
+            guard let self, let m = self.project.markers.first(where: { $0.id == id })
+            else { return }
+            let menu = self.markerMenu(for: m)
+            menu.popUp(positioning: nil,
+                       at: NSPoint(x: self.xFor(m.time) - 4, y: self.rulerH + 2),
+                       in: self)
+        }
+    }
 
     override func menu(for event: NSEvent) -> NSMenu? {
         let p = convert(event.locationInWindow, from: nil)
@@ -3599,23 +4712,8 @@ final class TimelineView: NSView {
 
         // Ruler: markers (rename/delete an existing flag, or add one here).
         if p.y < rulerH {
-            if let m = markerAt(point: p) {
-                ctxMarkerId = m.id
-                // Name lives inline in the menu (like Frame Rate), not a popup.
-                // Committed on menuDidClose so Return / click-away all persist.
-                let nameField = MarkerNameMenuField(name: m.label)
-                nameField.onReturn = { [weak menu] in menu?.cancelTracking() }
-                markerNameField = nameField
-                markerNameOriginal = m.label
-                menu.delegate = self
-                let nameItem = NSMenuItem()
-                nameItem.view = nameField
-                menu.addItem(nameItem)
-                menu.addItem(.separator())
-                add("Delete Marker", #selector(ctxDeleteMarker), key: "\u{8}")
-            } else {
-                add("Add Marker Here", #selector(ctxAddMarkerHere))
-            }
+            if let m = markerAt(point: p) { return markerMenu(for: m) }
+            add("Add Marker Here", #selector(ctxAddMarkerHere), key: "m")
             if !project.markers.isEmpty {
                 menu.addItem(.separator())
                 add("Clear All Markers", #selector(ctxClearMarkers))
@@ -3675,7 +4773,27 @@ final class TimelineView: NSView {
                 add("Open in Storyboard Window", #selector(ctxOpenBoard))
             }
             add(clip.muted ? "Unmute" : "Mute", #selector(ctxMute), key: "m")
+            // Volume: inline slider row for any sound-producing clip; applies
+            // to the whole selection (link mates included) as one undo step.
+            let audible = clip.kind == .audio
+                || (clip.kind == .video
+                    && (clip.mediaId.flatMap { mediaById[$0] }?.hasAudio ?? false))
+            if audible {
+                volumeTargets = project.expandLinks(store.selection).union([clip.id])
+                volumeBaseModel = project
+                let vol = ClipVolumeMenuField(gain: clip.gain)
+                vol.onChange = { [weak self] g in self?.previewVolume(g) }
+                volumeField = vol
+                menu.delegate = self
+                let volItem = NSMenuItem()
+                volItem.view = vol
+                menu.addItem(volItem)
+            }
             if clip.speed != 1 { add("Reset Speed (×1)", #selector(ctxResetSpeed)) }
+            if let media = clip.mediaId.flatMap({ mediaById[$0] }) {
+                ctxRevealURL = media.url
+                add("Reveal in Finder", #selector(ctxRevealInFinder))
+            }
             menu.addItem(.separator())
             if store.selection.count > 1 { add("Link Clips", #selector(ctxLink), key: "g") }
             if clip.linkId != nil { add("Unlink Clips", #selector(ctxUnlink)) }
@@ -3715,12 +4833,16 @@ final class TimelineView: NSView {
     @objc private func ctxClearMarkers() { clearAllMarkers() }
     @objc private func ctxAddMarkerHere() {
         let t = max(0, quantize(secondsFor(lastMousePoint.x)))
+        var added: UUID?
         store.mutate { model in
             let half = 0.5 / max(1, model.fps)
             if !model.markers.contains(where: { abs($0.time - t) < half }) {
-                model.markers.append(Marker(time: t))
+                let m = Marker(time: t)
+                added = m.id
+                model.markers.append(m)
             }
         }
+        if let id = added { placeDidAddMarker(id) }
     }
     @objc private func ctxToggleFusionHidden() { session.fusionHidden.toggle(); needsDisplay = true }
     @objc private func ctxToggleFusionFocus() { session.fusionFocus.toggle(); needsDisplay = true }
@@ -3760,6 +4882,24 @@ final class TimelineView: NSView {
     }
     @objc private func ctxLink() { linkSelection() }
     @objc private func ctxUnlink() { unlinkSelection() }
+    @objc private func ctxRevealInFinder() {
+        if let url = ctxRevealURL {
+            NSWorkspace.shared.activateFileViewerSelecting([url])
+        }
+    }
+    /// Live volume from the menu slider: preview (non-undoable) + a direct
+    /// player sync, because menu tracking can starve the 60 Hz tick and the
+    /// change should be audible while the slider moves.
+    private func previewVolume(_ gain: Double) {
+        let ids = volumeTargets
+        guard !ids.isEmpty else { return }
+        store.preview { model in
+            for i in model.clips.indices where ids.contains(model.clips[i].id) {
+                model.clips[i].gain = gain
+            }
+        }
+        ctx.players.sync(force: false)
+    }
     @objc private func ctxCopy() { copy(nil) }
     @objc private func ctxToggleNewShot() { toggleNewShot() }
     @objc private func ctxPanelLater() { addPanelOneSecondLater() }
@@ -3784,7 +4924,18 @@ final class TimelineView: NSView {
     }
 
     override func scrollWheel(with event: NSEvent) {
-        if event.modifierFlags.contains(.command) {
+        let mods = event.modifierFlags
+        if mods.contains(.command) && mods.contains(.option) {
+            // ⌥⌘-scroll: vertical zoom — scale track heights (the scroll
+            // counterpart of ⌥⌘= / ⌥⌘-), keeping the lane under the cursor
+            // in place. laneScale's setter clamps the range.
+            let p = convert(event.locationInWindow, from: nil)
+            let old = session.laneScale
+            session.laneScale = old * (1 + event.scrollingDeltaY * 0.01)
+            let k = session.laneScale / old
+            let yInLanes = max(0, p.y - lanesTop)
+            scrollY = min(max(0, (scrollY + yInLanes) * k - yInLanes), maxScrollY)
+        } else if mods.contains(.command) {
             zoom(by: 1 + event.scrollingDeltaY * 0.01, anchorX: convert(event.locationInWindow, from: nil).x)
         } else {
             let dy = event.scrollingDeltaY
@@ -4052,6 +5203,13 @@ final class TimelineView: NSView {
     // MARK: - Test hooks
 
     func testXFor(_ seconds: Double) -> CGFloat { xFor(seconds) }
+    func testLaneMidY(_ row: Int) -> CGFloat { laneRect(row: row).midY }
+    func testLaneRect(_ row: Int) -> NSRect { laneRect(row: row) }
+    func testHeaderButtonRects(_ row: Int) -> (hide: NSRect, focus: NSRect, color: NSRect?) {
+        headerButtonRects(lane: laneRect(row: row))
+    }
+    var testHeaderW: CGFloat { headerW }
+    func testDragInfo() -> String { "\(drag.mode) clip=\(drag.clipId != nil) sel=\(drag.origSelection.count)" }
     var testPxPerSecond: Double { pxPerSecond }
     func testHThumb() -> NSRect { hThumbRect() }
     func testVThumb() -> NSRect { vThumbRect() }
@@ -4066,7 +5224,8 @@ final class TimelineView: NSView {
     // MARK: - Colors
 
     private func trackColor(_ ref: TrackRef) -> NSColor {
-        NSColor(calibratedHue: project.hue(for: ref), saturation: 0.55, brightness: 0.85, alpha: 1)
+        if ref.isReaper { return Theme.reaperGreen }   // exact #06FD99, not hue-derived
+        return NSColor(calibratedHue: project.hue(for: ref), saturation: 0.55, brightness: 0.85, alpha: 1)
     }
     private func trackColorForClip(_ clip: Clip) -> NSColor {
         trackColor(clip.track)
@@ -4078,10 +5237,19 @@ extension TimelineView: NSMenuDelegate {
     /// Return, click-away, or picking another item. One undo step, and none at
     /// all if the name is unchanged.
     func menuDidClose(_ menu: NSMenu) {
-        guard let field = markerNameField, let id = ctxMarkerId else { return }
-        markerNameField = nil
-        let value = field.text.trimmingCharacters(in: .whitespacesAndNewlines)
-        if value != markerNameOriginal { setMarkerLabel(id, value) }
+        if let field = markerNameField, let id = ctxMarkerId {
+            markerNameField = nil
+            let value = field.text.trimmingCharacters(in: .whitespacesAndNewlines)
+            if value != markerNameOriginal { setMarkerLabel(id, value) }
+        }
+        // The volume slider previews live (non-undoable); the whole excursion
+        // lands as ONE undo step against the pre-menu model when the menu goes.
+        if volumeField != nil, let base = volumeBaseModel {
+            volumeField = nil
+            volumeBaseModel = nil
+            volumeTargets = []
+            store.commitPreview(from: base)
+        }
     }
 }
 
@@ -4109,6 +5277,9 @@ final class MarkerNameMenuField: NSView, NSTextFieldDelegate {
     private(set) var text: String
     /// Set by the menu builder so Return dismisses the menu (which commits).
     var onReturn: (() -> Void)?
+    /// Backspace in an ALREADY-EMPTY field deletes the marker (the menu's
+    /// Delete Marker item itself needs ⌘⌫ so typing can't trigger it).
+    var onDeleteEmpty: (() -> Void)?
 
     init(name: String) {
         self.text = name
@@ -4143,4 +5314,79 @@ final class MarkerNameMenuField: NSView, NSTextFieldDelegate {
 
     func controlTextDidChange(_ obj: Notification) { text = field.stringValue }
     @objc private func returnPressed() { onReturn?() }
+
+    func control(_ control: NSControl, textView: NSTextView,
+                 doCommandBy commandSelector: Selector) -> Bool {
+        if commandSelector == #selector(NSResponder.deleteBackward(_:)),
+           textView.string.isEmpty {
+            onDeleteEmpty?()
+            return true
+        }
+        return false
+    }
+}
+
+/// Inline volume row in a clip's right-click menu: a slider (0–200%, unity at
+/// center) plus an editable percent field, applied live through Store.preview
+/// and committed as one undo step by TimelineView.menuDidClose. Deliberately
+/// menu-hosted — one number doesn't justify an inspector panel.
+final class ClipVolumeMenuField: NSView, NSTextFieldDelegate {
+    private let slider = NSSlider()
+    private let field = NSTextField()
+    /// Linear gain (1 = unity). Kept current from either control.
+    private(set) var value: Double
+    var onChange: ((Double) -> Void)?
+
+    init(gain: Double) {
+        value = gain
+        super.init(frame: NSRect(x: 0, y: 0, width: 232, height: 26))
+        let caption = NSTextField(labelWithString: "Volume")
+        caption.font = .menuFont(ofSize: 0)
+        caption.textColor = .secondaryLabelColor
+        caption.frame = NSRect(x: 14, y: 5, width: 48, height: 16)
+        addSubview(caption)
+        slider.frame = NSRect(x: 64, y: 3, width: 104, height: 20)
+        slider.minValue = 0
+        slider.maxValue = 2
+        slider.doubleValue = gain
+        slider.numberOfTickMarks = 3   // 0%, the 100% detent, 200%
+        slider.allowsTickMarkValuesOnly = false
+        slider.isContinuous = true
+        slider.target = self
+        slider.action = #selector(slid)
+        addSubview(slider)
+        field.frame = NSRect(x: 172, y: 3, width: 46, height: 20)
+        field.font = .menuFont(ofSize: 0)
+        field.focusRingType = .none
+        field.alignment = .right
+        field.delegate = self
+        field.target = self
+        field.action = #selector(typed)
+        addSubview(field)
+        syncField()
+    }
+    required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") }
+
+    private func syncField() {
+        field.stringValue = "\(Int((value * 100).rounded()))%"
+    }
+    @objc private func slid() {
+        // Gentle detent: snap to unity when close so 100% is easy to re-hit.
+        var v = slider.doubleValue
+        if abs(v - 1) < 0.05 { v = 1; slider.doubleValue = 1 }
+        value = v
+        syncField()
+        onChange?(value)
+    }
+    @objc private func typed() { applyFieldText(final: true) }
+    func controlTextDidChange(_ obj: Notification) { applyFieldText(final: false) }
+    private func applyFieldText(final: Bool) {
+        let digits = field.stringValue.trimmingCharacters(
+            in: CharacterSet(charactersIn: "% \t"))
+        guard let pct = Double(digits) else { if final { syncField() }; return }
+        value = min(2, max(0, pct / 100))
+        slider.doubleValue = value
+        if final { syncField() }
+        onChange?(value)
+    }
 }
diff --git a/sequencer/Sources/Sequencer/Tools.swift b/sequencer/Sources/Sequencer/Tools.swift
index d5e48259f4cb98378275ee63e4d43a7edcf643dd..ed60c8502e4daad1ef7aa4f356c721fac8558a01 100644
--- a/sequencer/Sources/Sequencer/Tools.swift
+++ b/sequencer/Sources/Sequencer/Tools.swift
@@ -3,13 +3,13 @@ import AppKit
 /// Tools for the MAIN window's toolbar: editing tools work on the timeline,
 /// drawing tools work directly on storyboard preview cells.
 enum MainTool: CaseIterable {
-    case select, blade, slide, pencil, pen, thick, eraser
+    case select, blade, slip, pencil, pen, thick, eraser
 
     var label: String {
         switch self {
         case .select: return "Select"
         case .blade: return "Blade"
-        case .slide: return "Slide"
+        case .slip: return "Slip"
         case .pencil: return "Pencil"
         case .pen: return "Pen"
         case .thick: return "Thick Pen"
@@ -30,7 +30,7 @@ enum MainTool: CaseIterable {
         switch self {
         case .select: return "cursorarrow"
         case .blade: return "scissors"
-        case .slide: return "arrow.left.and.right.square"
+        case .slip: return "arrow.left.and.right.square"
         case .pencil: return "pencil"
         case .pen: return "pencil.tip"
         case .thick: return "paintbrush.pointed.fill"
diff --git a/sequencer/Sources/Sequencer/Transcript.swift b/sequencer/Sources/Sequencer/Transcript.swift
index 7dd5a57f8d1b4179b7912f0c1a165c6f2a2df40b..13795b96cd795d3d2aaf008df95351feb403ca71 100644
--- a/sequencer/Sources/Sequencer/Transcript.swift
+++ b/sequencer/Sources/Sequencer/Transcript.swift
@@ -68,20 +68,40 @@ struct Transcript {
 
     // MARK: Sibling-file loading (cached)
 
-    private static var cache: [String: Transcript?] = [:]
+    private static var cache: [String: Transcript?] = [:]   // main-thread only
+    private static var loading = Set<String>()               // main-thread only
+    private static let loadQueue = DispatchQueue(label: "sequencer.transcript",
+                                                 qos: .utility)
 
     /// The transcript for a media file, or nil unless it is named `cam.mov` and
     /// has a readable `transcript.json` in the same folder. Cached by path so
-    /// the per-frame visibility probe is cheap.
+    /// the per-frame visibility probe is cheap. A cache MISS reads and parses
+    /// OFF MAIN and returns nil for now — this runs per playhead tick, and the
+    /// old synchronous `Data(contentsOf:)` froze playback for most of a second
+    /// whenever the NAS was cold (the fstat/readDataFromFile `[hang]`).
+    /// `.viewerNeedsRefresh` fires when the parse lands.
     static func load(forVideo url: URL) -> Transcript? {
         guard url.lastPathComponent.lowercased() == "cam.mov" else { return nil }
-        let path = url.deletingLastPathComponent()
-            .appendingPathComponent("transcript.json").path
+        // String-side path math: URL's appendingPathComponent stat()s the disk
+        // (is it a directory?) — this runs per lane per subtitle sync.
+        let path = ((url.path as NSString).deletingLastPathComponent as NSString)
+            .appendingPathComponent("transcript.json")
         if let hit = cache[path] { return hit }
-        let parsed = (try? Data(contentsOf: URL(fileURLWithPath: path)))
-            .flatMap { parse($0, key: path) }
-        cache[path] = parsed
-        return parsed
+        guard !loading.contains(path) else { return nil }
+        loading.insert(path)
+        loadQueue.async {
+            let parsed = (try? Data(contentsOf: URL(fileURLWithPath: path)))
+                .flatMap { parse($0, key: path) }
+            DispatchQueue.main.async {
+                loading.remove(path)
+                cache[path] = parsed        // negative results cached too
+                if parsed != nil {
+                    NotificationCenter.default.post(name: .viewerNeedsRefresh,
+                                                    object: nil)
+                }
+            }
+        }
+        return nil
     }
 
     /// Drop cached parses so a re-imported/edited transcript is re-read.
@@ -264,7 +284,7 @@ final class SubtitleOverlay: NSView {
     /// bearing `cam.mov`. Mirrors the viewer's own hide/focus visibility rule;
     /// the Priority pane wins when it qualifies.
     private func transcriptClipUnderPlayhead() -> (Clip, MediaItem)? {
-        let project = store.project
+        let index = store.index
         let t = playback.playhead
         let focusActive = !session.focusedTracks.isEmpty || session.fusionFocus
         func visible(_ ref: TrackRef) -> Bool {
@@ -272,9 +292,9 @@ final class SubtitleOverlay: NSView {
                         : !session.hiddenTracks.contains(ref)
         }
         var found: (TrackRef, Clip, MediaItem)?
-        for ref in project.laneRefs where visible(ref) {
-            guard let clip = project.clipAt(track: ref, time: t, kind: .video),
-                  let m = project.media(clip.mediaId),
+        for ref in index.laneRefs where visible(ref) {
+            guard let clip = index.clipAt(track: ref, time: t, kind: .video),
+                  let m = index.media(clip.mediaId),
                   Transcript.load(forVideo: m.url) != nil else { continue }
             if ref == session.priorityPane { return (clip, m) }
             if found == nil { found = (ref, clip, m) }
diff --git a/sequencer/Sources/Sequencer/TransportBar.swift b/sequencer/Sources/Sequencer/TransportBar.swift
index e335e77c18d0639f770da0a13d5246ddeaa32900..ad5b4d419015cf09f3ad2e1feaf89ee569beb523 100644
--- a/sequencer/Sources/Sequencer/TransportBar.swift
+++ b/sequencer/Sources/Sequencer/TransportBar.swift
@@ -73,6 +73,14 @@ final class TransportBar: NSView {
     private var chunks: ChunkManager { ctx.chunks }
     private var session: SessionState { ctx.session }
 
+    /// The document's MAIN window controller — owner of the previews layout and
+    /// the extra-timeline-window lifecycle. Resolved via the document (not
+    /// `window?.windowController`) so a toolbar hosted in an extra timeline
+    /// window still reaches it.
+    private var mainWC: SequencerWindowController? {
+        ctx.document?.windowControllers.compactMap { $0 as? SequencerWindowController }.first
+    }
+
     private let timecode = NSTextField(labelWithString: "00:00:00:00")
     private let fpsButton = InstantButton(title: "", target: nil, action: nil)
     private let customFpsField = NSTextField()
@@ -159,7 +167,7 @@ final class TransportBar: NSView {
             styleIconButton(b, tip: tool.tip)
             toolButtons[tool] = b
             leftViews.append(b)
-            if tool == .slide {
+            if tool == .slip {
                 let sep = NSBox(); sep.boxType = .separator
                 sep.heightAnchor.constraint(equalToConstant: 18).isActive = true
                 leftViews.append(sep)
@@ -260,7 +268,7 @@ final class TransportBar: NSView {
         heightSlider.controlSize = .small
         heightSlider.target = self
         heightSlider.action = #selector(heightChanged)
-        heightSlider.toolTip = "Track height (⌥⌘= / ⌥⌘- / ⌥⌘0)"
+        heightSlider.toolTip = "Track height (⌥⌘= / ⌥⌘- / ⌥⌘0, or ⌥⌘-scroll in the timeline)"
         heightSlider.widthAnchor.constraint(equalToConstant: 80).isActive = true
 
         let rightStack = NSStackView(views: [netWarn, jobs, snapButton, subtitleButton,
@@ -412,17 +420,27 @@ final class TransportBar: NSView {
                              keyEquivalent: "P")
         pop.keyEquivalentModifierMask = [.command, .shift]
         pop.target = self
-        pop.state = ((window?.windowController as? SequencerWindowController)?.previewsArePopped ?? false) ? .on : .off
+        pop.state = (mainWC?.previewsArePopped ?? false) ? .on : .off
         menu.addItem(pop)
+        menu.addItem(.separator())
+        let newTL = NSMenuItem(title: "New Timeline Window",
+                               action: #selector(openTimelineWindow), keyEquivalent: "t")
+        newTL.keyEquivalentModifierMask = [.command, .shift]
+        newTL.target = self
+        menu.addItem(newTL)
         menu.popUp(positioning: nil,
                    at: NSPoint(x: 0, y: viewerButton.bounds.maxY + 4), in: viewerButton)
     }
 
+    @objc private func openTimelineWindow() {
+        mainWC?.openSecondaryTimeline()
+    }
+
     @objc private func toggleSide() {
-        (window?.windowController as? SequencerWindowController)?.togglePreviewsLeft()
+        mainWC?.togglePreviewsLeft()
     }
     @objc private func togglePopout() {
-        (window?.windowController as? SequencerWindowController)?.togglePopout()
+        mainWC?.togglePopout()
     }
 
     @objc private func fpsClicked() {
@@ -624,7 +642,7 @@ final class TransportBar: NSView {
         highlight(subtitleButton, session.subtitlesEnabled)
         highlight(filmstripButton, session.showFilmstrips)
         highlight(viewerButton, session.previewsOnLeft
-                  || ((window?.windowController as? SequencerWindowController)?.previewsArePopped ?? false))
+                  || (mainWC?.previewsArePopped ?? false))
     }
 
     // MARK: - Readouts
diff --git a/sequencer/Sources/Sequencer/UITest.swift b/sequencer/Sources/Sequencer/UITest.swift
index 15b3fc006cd03cdcf7cd8b66814b22402f3cae79..aa002cbb3b9a752499ae02d90ec2f96c190dc8c4 100644
--- a/sequencer/Sources/Sequencer/UITest.swift
+++ b/sequencer/Sources/Sequencer/UITest.swift
@@ -168,14 +168,19 @@ func runUITest() {
           "linked move: both clips shift +10 (got \(clip(c0.id)!.start), \(clip(c1.id)!.start))")
 
     // 15. Linked split: cutting c0 at 45 also cuts c1; right halves share a new link.
+    let linkBefore15 = clip(c0.id)!.linkId
     DocumentContext.headless.playback.seek(to: 45)
     store.selection = [c0.id]
     timeline.split()
     check(store.project.clips.count == 4, "linked split cuts both clips")
     let rights = store.project.clips.filter { abs($0.start - 45) < 0.001 }
     check(rights.count == 2 && rights[0].linkId != nil && rights[0].linkId == rights[1].linkId
-          && rights[0].linkId != clip(c0.id)!.linkId,
+          && rights[0].linkId != linkBefore15,
           "right halves share a fresh linkId")
+    // The half AHEAD of the playhead keeps the original id, so the warm
+    // per-clip audio player rides through a split during playback.
+    check(rights.contains { $0.id == c0.id },
+          "split: the right half keeps the original clip id")
 
     // ---- Fresh model: overlaps, push-trim, storyboard, empty tracks ----
     var m2 = ProjectModel()
@@ -435,6 +440,22 @@ func runUITest() {
           && abs(audioGain(ac, at: 8) - 0.5) < 0.001
           && audioGain(ac, at: 11) == 0,
           "audio fade envelope")
+    // 27a. Clip volume scales the whole envelope; old files decode gain = 1.
+    var gc = ac
+    gc.gain = 0.5
+    check(abs(audioGain(gc, at: 5) - 0.5) < 0.001
+          && abs(audioGain(gc, at: 1) - 0.25) < 0.001,
+          "clip gain scales the fade envelope")
+    var noGainObj = try! JSONSerialization.jsonObject(
+        with: try! JSONEncoder().encode(ac)) as! [String: Any]
+    noGainObj.removeValue(forKey: "gain")
+    let decodedNoGain = try! JSONDecoder().decode(Clip.self,
+        from: try! JSONSerialization.data(withJSONObject: noGainObj))
+    check(decodedNoGain.gain == 1, "pre-gain clips decode at unity volume")
+    var gainRT = ac; gainRT.gain = 1.3
+    let gainBack = try! JSONDecoder().decode(
+        Clip.self, from: try! JSONEncoder().encode(gainRT))
+    check(abs(gainBack.gain - 1.3) < 1e-9, "gain round-trips through Codable")
 
     // 27b. Shuttle keeps doubling; the opposite key halves down to a stop.
     let pc = DocumentContext.headless.playback
@@ -570,6 +591,69 @@ func runUITest() {
           "ripple delete inside the span lands on the close point (got \(DocumentContext.headless.playback.playhead))")
     store.undo()
 
+    // 31c. Linked slip / ripple / stretch all act on the WHOLE link group.
+    // Two linked clips (tracks 0+1, [20,40), srcIn 30) plus a follower after the
+    // grabbed clip on track 0. Regression guard for the bug where slip/ripple/
+    // stretch edited only the grabbed clip and left its link-mates behind.
+    DocumentContext.headless.session.snapping = false
+    func seedLinkGroup() {
+        var ml = ProjectModel(); ml.fps = 30; ml.media = [media]
+        ml.tracks = [Track(hue: 0.2), Track(hue: 0.5)]
+        let lk = UUID()
+        ml.clips = [
+            Clip(mediaId: media.id, track: .video(0), start: 20, srcIn: 30, duration: 20,
+                 kind: .video, linkId: lk),
+            Clip(mediaId: media.id, track: .video(1), start: 20, srcIn: 30, duration: 20,
+                 kind: .video, linkId: lk),
+            Clip(mediaId: media.id, track: .video(0), start: 40, srcIn: 0, duration: 10),
+        ]
+        store.replaceForTest(ml)
+        timeline.zoomToFit()
+    }
+    func grp() -> (a: Clip, b: Clip, fol: Clip) {
+        let cs = store.project.clips.sorted { ($0.track.wire, $0.start) < ($1.track.wire, $1.start) }
+        return (cs[0], cs[2], cs[1])   // t0@20, t1@20, t0@40(follower)
+    }
+
+    // Linked slip: ⌥-drag one clip's body — both angles slip by the same amount,
+    // starts unchanged, the follower stays put.
+    seedLinkGroup()
+    drag(from: winPoint(x(30), laneY(0)), to: winPoint(x(40), laneY(0)), flags: [.option])
+    var g = grp()
+    check(abs(g.a.srcIn - 20) < 0.6 && abs(g.b.srcIn - 20) < 0.6
+          && abs(g.a.start - 20) < 1e-6 && abs(g.b.start - 20) < 1e-6
+          && abs(g.fol.start - 40) < 1e-6,
+          "linked slip: both angles srcIn 30→~20, follower unmoved (got \(g.a.srcIn), \(g.b.srcIn))")
+
+    // Linked ripple-out: ⌥-drag the out edge +10 — both durations grow, and the
+    // follower on the grabbed clip's track shifts by the same 10.
+    seedLinkGroup()
+    drag(from: winPoint(x(40) - 3, laneY(0)), to: winPoint(x(50) - 3, laneY(0)), flags: [.option])
+    g = grp()
+    check(abs(g.a.duration - 30) < 0.6 && abs(g.b.duration - 30) < 0.6
+          && abs(g.fol.start - 50) < 0.6,
+          "linked ripple-out: both durations 20→~30, follower 40→~50 (got \(g.a.duration), \(g.b.duration), \(g.fol.start))")
+
+    // Linked ripple-in: ⌥-drag the in edge +10 — both heads trim (srcIn up, dur
+    // down), follower pulls in.
+    seedLinkGroup()
+    drag(from: winPoint(x(20) + 3, laneY(0)), to: winPoint(x(30) + 3, laneY(0)), flags: [.option])
+    g = grp()
+    check(abs(g.a.srcIn - 40) < 0.6 && abs(g.b.srcIn - 40) < 0.6
+          && abs(g.a.duration - 10) < 0.6 && abs(g.b.duration - 10) < 0.6
+          && abs(g.fol.start - 30) < 0.6,
+          "linked ripple-in: both srcIn 30→~40 dur 20→~10, follower 40→~30 (got \(g.a.srcIn), \(g.b.srcIn), \(g.fol.start))")
+
+    // Linked stretch: ⌘-drag the out edge — both angles time-stretch (speed drops,
+    // source range constant) in lock-step.
+    seedLinkGroup()
+    drag(from: winPoint(x(40) - 3, laneY(0)), to: winPoint(x(45) - 3, laneY(0)), flags: [.command])
+    g = grp()
+    check(g.a.speed < 1 && g.b.speed < 1
+          && abs(g.a.sourceLength - 20) < 0.4 && abs(g.b.sourceLength - 20) < 0.4
+          && abs(g.a.duration - g.b.duration) < 0.1,
+          "linked stretch: both angles slow in sync, srcLen kept (got \(g.a.speed), \(g.b.speed))")
+
     // 31b. Trailing empty tracks collapse to the last used lane; interior and
     // top empties stay (so dragging a clip down two rows still makes two).
     var mp = ProjectModel(); mp.fps = 30; mp.media = [media]
@@ -608,6 +692,28 @@ func runUITest() {
     check(lcs.count == 2 && abs(lcs[1].start - 20) < 1e-6 && abs(lcs[1].duration - 15) < 1e-6,
           "⌥← ripple-trims the left side to the playhead")
 
+    // 31d-nr. ⇧D "Delete Right" = same right-trim WITHOUT the ripple: clip0
+    // shrinks to the playhead, but the follower stays put (freed span is a gap).
+    store.replaceForTest(mr)
+    store.selection = []
+    DocumentContext.headless.playback.seek(to: 10)
+    timeline.rippleTrimToPlayhead(deleteLeft: false, ripple: false)
+    let nrr = store.project.clips.sorted { $0.start < $1.start }
+    check(nrr.count == 2 && abs(nrr[0].duration - 10) < 1e-6
+          && abs(nrr[1].start - 20) < 1e-6 && abs(nrr[1].end - 40) < 1e-6,
+          "⇧D delete-right trims to the playhead and leaves a gap (follower unmoved)")
+
+    // 31e-nr. ⇧A "Delete Left" = left-trim WITHOUT the ripple: the clip under the
+    // playhead starts at the playhead, nothing slides, and clip0 is untouched.
+    store.replaceForTest(mr)
+    store.selection = []
+    DocumentContext.headless.playback.seek(to: 25)   // inside the second clip [20,40)
+    timeline.rippleTrimToPlayhead(deleteLeft: true, ripple: false)
+    let nrl = store.project.clips.sorted { $0.start < $1.start }
+    check(nrl.count == 2 && abs(nrl[0].start - 0) < 1e-6 && abs(nrl[0].end - 20) < 1e-6
+          && abs(nrl[1].start - 25) < 1e-6 && abs(nrl[1].duration - 15) < 1e-6,
+          "⇧A delete-left trims the head to the playhead and leaves a gap (predecessor unmoved)")
+
     // 31d-ripple. ⌥-drag a clip's IN edge = ripple trim: the clip's start stays
     // pinned, its in-point re-trims, and the follower shifts to stay gapless.
     // Media out-point is fixed, so the source range only loses (or regains)
@@ -746,6 +852,55 @@ func runUITest() {
           "v-bar end drag scales lanes (got \(String(format: "%.2f", DocumentContext.headless.session.laneScale)))")
     DocumentContext.headless.session.laneScale = 1
 
+    // 35b. Track-height resize is HEADER-ONLY (left column), and header
+    // hide/focus targets hit the buttons where they're drawn — not the old
+    // crude "upper half hides / lower half focuses" split.
+    var mh = ProjectModel()
+    mh.fps = 30
+    mh.media = [media]
+    mh.tracks = [Track(hue: 0.1), Track(hue: 0.5)]
+    mh.clips = [Clip(mediaId: media.id, track: .video(0), start: 0, srcIn: 0, duration: 40),
+                Clip(mediaId: media.id, track: .video(1), start: 0, srcIn: 0, duration: 40)]
+    store.replaceForTest(mh)
+    let sess = DocumentContext.headless.session
+    sess.laneScale = 1; sess.trackHeights = [:]
+    sess.hiddenTracks = []; sess.focusedTracks = []
+    timeline.zoomToFit()
+    let hw = timeline.testHeaderW
+
+    // (a) A boundary drag over the CLIP body must NOT resize the track.
+    let laneA = timeline.testLaneRect(0)
+    drag(from: winPoint(timeline.testXFor(20), laneA.maxY),
+         to: winPoint(timeline.testXFor(20), laneA.maxY + 40))
+    check(sess.trackHeights[.video(0)] == nil,
+          "boundary drag over the clip body does not resize the track")
+    store.replaceForTest(mh)   // the body drag may have moved a clip — reset
+    sess.trackHeights = [:]; store.selection = []
+
+    // (b) The same boundary drag inside the HEADER resizes the track taller.
+    let laneB = timeline.testLaneRect(0)
+    drag(from: winPoint(hw / 2, laneB.maxY), to: winPoint(hw / 2, laneB.maxY + 40))
+    check((sess.trackHeights[.video(0)] ?? 1) > 1.2,
+          "boundary drag in the header resizes the track (got \(sess.trackHeights[.video(0)] ?? 1))")
+    sess.trackHeights = [:]
+
+    // (c) Clicking the FOCUS glyph toggles focus (not hide).
+    let hr = timeline.testHeaderButtonRects(0)
+    timeline.mouseDown(with: mouse(.leftMouseDown, winPoint(hr.focus.midX, hr.focus.midY)))
+    timeline.mouseUp(with: mouse(.leftMouseUp, winPoint(hr.focus.midX, hr.focus.midY)))
+    check(sess.focusedTracks.contains(.video(0)) && !sess.hiddenTracks.contains(.video(0)),
+          "clicking the header focus glyph toggles focus, not hide")
+    sess.focusedTracks = []
+
+    // (d) Clicking dead space above the hide glyph toggles NOTHING (the old
+    // midY split would have spuriously toggled hide here).
+    let laneD = timeline.testLaneRect(0)
+    timeline.mouseDown(with: mouse(.leftMouseDown, winPoint(hw / 2, laneD.minY + 1)))
+    timeline.mouseUp(with: mouse(.leftMouseUp, winPoint(hw / 2, laneD.minY + 1)))
+    check(!sess.hiddenTracks.contains(.video(0)) && !sess.focusedTracks.contains(.video(0)),
+          "clicking header dead space toggles nothing")
+    sess.hiddenTracks = []; sess.focusedTracks = []
+
     // 36. Adaptive proxy quality controller (pure decision function).
     let nLevels = ChunkManager.qualities.count
     // Fast build at full quality → hold (stay at 0).
@@ -795,10 +950,27 @@ func runUITest() {
     check(store.project.markers.count == 1
           && store.project.markers.first.map { abs($0.time - 20) < 1e-6 } == true,
           "⇧M on a marker removes it")
-    // Click the ruler flag to park the playhead there.
+    // Click the ruler flag (down+up, no drag — the seek commits on mouseUp
+    // now that flags are draggable) to park the playhead there. The flag only
+    // occupies the LOWER ~14pt of the ruler; view y=20 is inside it.
     pc.seek(to: 0)
-    timeline.mouseDown(with: mouse(.leftMouseDown, winPoint(x(20) + 3, 4)))
+    timeline.mouseDown(with: mouse(.leftMouseDown, winPoint(x(20) + 3, 20)))
+    timeline.mouseUp(with: mouse(.leftMouseUp, winPoint(x(20) + 3, 20)))
     check(abs(pc.playhead - 20) < 1e-6, "clicking a marker flag seeks to it")
+    // The strip ABOVE the flag stays scrub territory: dragging there must
+    // scrub, not grab the marker.
+    DocumentContext.headless.session.snapping = false
+    drag(from: winPoint(x(20) + 3, 4), to: winPoint(x(32) + 3, 4))
+    check(abs((store.project.markers.first?.time ?? -1) - 20) < 1e-6,
+          "dragging above the flag scrubs; the marker stays put")
+    // Dragging the flag itself slides the marker (one undo step).
+    drag(from: winPoint(x(20) + 3, 20), to: winPoint(x(32) + 3, 20))
+    check(store.project.markers.count == 1
+          && abs((store.project.markers.first?.time ?? -1) - 32) < 0.5,
+          "dragging a marker flag moves it (got \(store.project.markers.first?.time ?? -1))")
+    store.undo()
+    check(abs((store.project.markers.first?.time ?? -1) - 20) < 1e-6,
+          "undo restores the dragged marker")
     timeline.clearAllMarkers()
     check(store.project.markers.isEmpty, "Clear All Markers empties them")
     // Markers survive a save/load round-trip.
@@ -917,6 +1089,411 @@ func runUITest() {
           && healed == MediaPipeline.normalizedCacheKey(for: badMedia),
           "cacheKey self-heals to a stable valid key")
 
+    // 43. ClipIndex answers match the model's O(n) queries on a randomized
+    // project — overlaps, gaps, storyboard lane, latest-start-wins ties.
+    var xp = ProjectModel()
+    xp.tracks = [Track(hue: 0.1), Track(hue: 0.2)]
+    var rmediaA = MediaItem(path: "/tmp/idx-a.mov"); rmediaA.hasAudio = true
+    let rmediaB = MediaItem(path: "/tmp/idx-b.mov")
+    xp.media = [rmediaA, rmediaB]
+    var rng = SystemRandomNumberGenerator()
+    for i in 0..<120 {
+        let track: TrackRef = i % 5 == 0 ? .storyboard
+            : .video(Int.random(in: 0...1, using: &rng))
+        let kind: ClipKind = track == .storyboard ? .storyboard
+            : (i % 4 == 0 ? .audio : .video)
+        var c = Clip(mediaId: i % 3 == 0 ? rmediaA.id : rmediaB.id, track: track,
+                     start: Double(Int.random(in: 0...200, using: &rng)),
+                     srcIn: 0, duration: Double(Int.random(in: 1...30, using: &rng)),
+                     kind: kind)
+        if kind == .storyboard { c.board = Board() }
+        xp.clips.append(c)
+    }
+    let idx = ClipIndex(xp)
+    var idxOK = true
+    for t in stride(from: -1.0, through: 210, by: 0.7) {
+        for ref in [TrackRef.video(0), .video(1), .storyboard] {
+            for kind in [ClipKind.video, .audio, .storyboard] {
+                if idx.clipAt(track: ref, time: t, kind: kind)?.id
+                    != xp.clipAt(track: ref, time: t, kind: kind)?.id { idxOK = false }
+            }
+        }
+    }
+    check(idxOK, "ClipIndex.clipAt matches model on a randomized project")
+    var winOK = true
+    for t in stride(from: -1.0, through: 210, by: 1.3) {
+        let want = Set(xp.clips.filter { (c: Clip) -> Bool in
+            let audible = c.kind == .audio
+                || (c.kind == .video && xp.media(c.mediaId)?.hasAudio == true)
+            return audible && t + 1.0 >= c.start && t - 0.5 < c.end
+        }.map { $0.id })
+        let got = Set(idx.audibleClips(from: t - 0.5, to: t + 1.0).map { $0.id })
+        if want != got { winOK = false }
+    }
+    check(winOK, "ClipIndex.audibleClips matches the model's window filter")
+
+    // 44. Move-gesture upgrades: ⌘-drag duplicates, multi-clip selections can
+    // grow tracks below the bottom lane, linked groups move vertically.
+    var m44 = ProjectModel(); m44.fps = 30; m44.media = [media]
+    m44.tracks = [Track(hue: 0.3)]
+    let g0 = Clip(mediaId: media.id, track: .video(0), start: 0, srcIn: 0, duration: 10)
+    let g1 = Clip(mediaId: media.id, track: .video(0), start: 20, srcIn: 0, duration: 10)
+    m44.clips = [g0, g1]
+    store.replaceForTest(m44)
+    store.selection = []
+    DocumentContext.headless.session.snapping = false
+    timeline.zoomToFit()
+
+    // ⌘-drag a clip body: the original stays put, a fresh copy takes the move.
+    drag(from: winPoint(x(5), laneY(0)), to: winPoint(x(12), laneY(0)), flags: [.command])
+    check(store.project.clips.count == 3 && abs(clip(g0.id)!.start - 0) < 1e-6,
+          "⌘-drag: original stays, a copy is added")
+    let copy44 = store.project.clips.first { $0.id != g0.id && $0.id != g1.id }
+    check(copy44.map { abs($0.start - 7) < 0.5 } == true,
+          "⌘-drag: the copy took the move (got \(copy44?.start ?? -1))")
+    check(copy44.map { store.selection == [$0.id] } == true,
+          "⌘-drag: the copy ends up selected")
+    store.undo()
+    check(store.project.clips.count == 2, "undo removes the ⌘-drag copy in one step")
+
+    // Both clips live on the single track; dragging the selection one row
+    // below the bottom creates the track and moves the whole group onto it.
+    store.selection = [g0.id, g1.id]
+    drag(from: winPoint(x(5), laneY(0)), to: winPoint(x(5), laneY(1)))
+    check(store.project.tracks.count == 2
+          && clip(g0.id)!.track == .video(1) && clip(g1.id)!.track == .video(1),
+          "multi-clip drag below the bottom grows a track and moves the group")
+    store.undo()
+    check(store.project.tracks.count == 1, "undo removes the group's new track")
+
+    // A linked pair spanning both tracks drags down one row; the mate's
+    // destination doesn't exist yet, so the drag grows it.
+    var m44b = ProjectModel(); m44b.fps = 30; m44b.media = [media]
+    m44b.tracks = [Track(hue: 0.1), Track(hue: 0.2)]
+    var l0 = Clip(mediaId: media.id, track: .video(0), start: 0, srcIn: 0, duration: 10)
+    var l1 = Clip(mediaId: media.id, track: .video(1), start: 0, srcIn: 0, duration: 10)
+    let lid44 = UUID(); l0.linkId = lid44; l1.linkId = lid44
+    m44b.clips = [l0, l1]
+    store.replaceForTest(m44b)
+    store.selection = []
+    timeline.zoomToFit()
+    drag(from: winPoint(x(5), laneY(0)), to: winPoint(x(5), laneY(1)))
+    check(store.project.tracks.count == 3
+          && clip(l0.id)!.track == .video(1) && clip(l1.id)!.track == .video(2),
+          "linked pair moves down a row, growing a track for the mate")
+    // And back up: the pair returns to rows 0/1 (no track creation needed).
+    drag(from: winPoint(x(5), laneY(1)), to: winPoint(x(5), laneY(0)))
+    check(clip(l0.id)!.track == .video(0) && clip(l1.id)!.track == .video(1),
+          "linked pair moves back up a row")
+
+    // 45. Audio isn't frame-bound: an audio-only move lands sub-frame; the
+    // same drag on a video clip quantizes to the grid.
+    var m45 = ProjectModel(); m45.fps = 30; m45.media = [media]
+    m45.tracks = [Track(hue: 0.5), Track(hue: 0.6)]
+    let sa = Clip(mediaId: media.id, track: .video(0), start: 10, srcIn: 0,
+                  duration: 10, kind: .audio)
+    let sv = Clip(mediaId: media.id, track: .video(1), start: 10, srcIn: 0, duration: 10)
+    m45.clips = [sa, sv]
+    store.replaceForTest(m45)
+    store.selection = []
+    DocumentContext.headless.session.snapping = false
+    timeline.zoomToFit()
+    drag(from: winPoint(x(15), laneY(0)), to: winPoint(x(15.05), laneY(0)))
+    let saStart = clip(sa.id)!.start
+    check(abs(saStart - 10.05) < 0.005,
+          "audio move is sub-frame (got \(saStart), grid would give 10.0333/10.0667)")
+    store.undo()
+    drag(from: winPoint(x(15), laneY(1)), to: winPoint(x(15.05), laneY(1)))
+    let svStart = clip(sv.id)!.start
+    check(abs(svStart * 30 - (svStart * 30).rounded()) < 1e-6,
+          "video move stays on the frame grid (got \(svStart))")
+
+    // 46. FrameCache residency ledger: the timeline's RAM indicator reads
+    // `residentQuality`, which must track installs (±1 bucket, like `image`),
+    // record the source tier, upgrade in place, and unbook on eviction
+    // (delegate — removeAll evicts everything through it).
+    let ctx46 = CGContext(data: nil, width: 8, height: 8, bitsPerComponent: 8,
+                          bytesPerRow: 0, space: CGColorSpaceCreateDeviceRGB(),
+                          bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue)!
+    let img46 = ctx46.makeImage()!
+    let fc = FrameCache.shared
+    check(fc.residentQuality(mediaKey: "fc-test", at: 5.0) == nil,
+          "framecache: empty ledger has no frame")
+    fc.installForTest(img46, mediaKey: "fc-test", at: 5.0, atTarget: false)
+    check(fc.residentQuality(mediaKey: "fc-test", at: 5.0) == false,
+          "framecache: reduced-tier install is resident as reduced")
+    check(fc.residentQuality(mediaKey: "fc-test", at: 5.2) == false,
+          "framecache: neighbor bucket counts as resident (same tolerance as image())")
+    fc.installForTest(img46, mediaKey: "fc-test", at: 5.0, atTarget: true)
+    check(fc.residentQuality(mediaKey: "fc-test", at: 5.0) == true,
+          "framecache: full-tier reinstall upgrades the ledger in place")
+    check(fc.residentQuality(mediaKey: "fc-test", at: 6.0) == nil,
+          "framecache: distant time is not resident")
+    check(fc.residentQuality(mediaKey: "fc-other", at: 5.0) == nil,
+          "framecache: other media is not resident")
+    fc.removeAllForTest()
+    check(fc.residentQuality(mediaKey: "fc-test", at: 5.0) == nil,
+          "framecache: eviction unbooks the residency ledger")
+
+    // 46b. LRU eviction order: a full cache evicts the least-recently-USED
+    // frame, never the one being inserted, and a read refreshes recency.
+    // (The old NSCache backing had neither property — at the budget it dumped
+    // the frames of the segment being PLAYED while stale ones squatted.)
+    let cost46 = img46.bytesPerRow * img46.height
+    fc.setBudgetForTest(bytes: cost46 * 3)
+    fc.installForTest(img46, mediaKey: "fc-lru", at: 10, atTarget: true)
+    fc.installForTest(img46, mediaKey: "fc-lru", at: 20, atTarget: true)
+    fc.installForTest(img46, mediaKey: "fc-lru", at: 30, atTarget: true)
+    var m46 = MediaItem(path: "/tmp/fc-lru.mov")
+    m46.cacheKey = "fc-lru"
+    check(fc.image(media: m46, at: 10) != nil,
+          "framecache: oldest frame still readable at budget")
+    fc.installForTest(img46, mediaKey: "fc-lru", at: 40, atTarget: true)
+    check(fc.residentQuality(mediaKey: "fc-lru", at: 40) == true,
+          "framecache: insert at full budget keeps the NEW frame")
+    check(fc.residentQuality(mediaKey: "fc-lru", at: 20) == nil,
+          "framecache: insert at full budget evicts the least-recently-used frame")
+    check(fc.residentQuality(mediaKey: "fc-lru", at: 10) == true,
+          "framecache: a read refreshes recency (replayed span stays hot)")
+    check(fc.residentQuality(mediaKey: "fc-lru", at: 30) == true,
+          "framecache: untouched-but-newer frame survives")
+    fc.removeAllForTest()
+    fc.refreshBudget()
+
+    // --- REAPER export (.rpp text generation) ---
+    do {
+        var rm = ProjectModel()
+        rm.fps = 30
+        var rMedia = MediaItem(path: "/tmp/take.mov")
+        rMedia.duration = 100; rMedia.fps = 30; rMedia.hasAudio = true
+        var rAudio = MediaItem(path: "/tmp/music.wav")
+        rAudio.duration = 100; rAudio.isAudio = true; rAudio.hasAudio = true
+        rm.media = [rMedia, rAudio]
+        rm.tracks = [Track(hue: 0.1), Track(hue: 0.5)]
+        // Track 0: a 2× speed clip at t=5 with fades and boosted gain.
+        var v0 = Clip(mediaId: rMedia.id, track: .video(0), start: 5, srcIn: 10, duration: 4)
+        v0.speed = 2; v0.fadeIn = 0.5; v0.fadeOut = 0.25; v0.gain = 1.5
+        // Track 1: a plain audio clip, plus a muted clip that must be dropped.
+        let a1 = Clip(mediaId: rAudio.id, track: .video(1), start: 8, srcIn: 0, duration: 12)
+        var muted = Clip(mediaId: rAudio.id, track: .video(1), start: 40, srcIn: 0, duration: 3)
+        muted.muted = true
+        // A storyboard panel — never audio, must be ignored.
+        let panel = Clip(mediaId: nil, track: .storyboard, start: 0, srcIn: 0, duration: 5,
+                         kind: .storyboard, board: Board())
+        rm.clips = [v0, a1, muted, panel]
+
+        let picked = ReaperExport.exportClips(rm)
+        check(picked.count == 2 && picked.contains { $0.id == v0.id } && picked.contains { $0.id == a1.id },
+              "reaper: exportClips takes audio-bearing unmuted clips, drops muted + storyboard")
+
+        let rpp = ReaperExport.rppText(project: rm, clips: picked,
+                                       stemPath: { "/stems/\($0.id.uuidString).wav" },
+                                       timestamp: 0)
+        check(rpp.hasPrefix("<REAPER_PROJECT") && rpp.contains("SAMPLERATE"),
+              "reaper: emits a project header")
+        check(rpp.components(separatedBy: "<TRACK ").count - 1 == 2,
+              "reaper: one <TRACK> per sequencer video track with clips")
+        check(rpp.components(separatedBy: "<ITEM").count - 1 == 2,
+              "reaper: one <ITEM> per exported clip (muted/storyboard excluded)")
+        check(rpp.contains("BEAT -1"), "reaper: tracks are time-based (no BPM coupling)")
+        check(rpp.contains("POSITION 5\n") || rpp.contains("POSITION 5 "),
+              "reaper: POSITION carries clip.start seconds")
+        check(rpp.contains("LENGTH 4\n") || rpp.contains("LENGTH 4 "),
+              "reaper: LENGTH carries clip.duration (timeline seconds)")
+        check(rpp.contains("PLAYRATE 2 0 0 -1 0 0.0025"),
+              "reaper: clip.speed maps to PLAYRATE")
+        check(rpp.contains("FADEIN 1 0.5 0 1 0 0") && rpp.contains("FADEOUT 1 0.25 0 1 0 0"),
+              "reaper: fades map to FADEIN/FADEOUT length (2nd arg)")
+        check(rpp.contains("VOLPAN 1.5 0 1 -1"), "reaper: clip.gain maps to VOLPAN volume")
+        check(rpp.contains("SOFFS 0\n"), "reaper: pre-trimmed stems => SOFFS 0")
+        check(rpp.contains("FILE \"/stems/\(v0.id.uuidString).wav\""),
+              "reaper: item references its baked stem path")
+        // Quote-selection: a name with a double-quote falls back to single quotes.
+        check(ReaperExport.quoted("a\"b") == "'a\"b'" && ReaperExport.quoted("plain") == "\"plain\"",
+              "reaper: RPP string quoting picks a delimiter not in the string")
+    }
+
+    // --- REAPER sidecar (v2): plan, migration, lanes, gesture rules ---
+    do {
+        check(TrackRef(wire: "r1") == .reaper(1) && TrackRef.reaper(3).wire == "r3",
+              "sidecar: TrackRef wire round-trip")
+
+        var sm = ProjectModel()
+        sm.fps = 30
+        var vMedia = MediaItem(path: "/tmp/take.mov")
+        vMedia.duration = 100; vMedia.fps = 30; vMedia.hasAudio = true
+        var aMedia = MediaItem(path: "/tmp/music.wav")
+        aMedia.duration = 100; aMedia.isAudio = true; aMedia.hasAudio = true
+        sm.media = [vMedia, aMedia]
+        sm.tracks = [Track(hue: 0.1), Track(hue: 0.5)]
+        var sv = Clip(mediaId: vMedia.id, track: .video(0), start: 5, srcIn: 10, duration: 4)
+        sv.speed = 2; sv.gain = 1.2
+        let sa = Clip(mediaId: aMedia.id, track: .video(1), start: 8, srcIn: 2,
+                      duration: 12, kind: .audio)
+        sm.clips = [sv, sa]
+
+        let plan = ReaperExport.buildPlan(project: sm,
+                                          clips: ReaperExport.exportClips(sm), startNumber: 1)
+        check(plan.tracks.map(\.name) == ["V1", "V2"], "sidecar: plan lanes V1/V2")
+        check(plan.entries.count == 2
+              && plan.entries.contains { $0.source.id == sv.id && $0.isSplit }
+              && plan.entries.contains { $0.source.id == sa.id && !$0.isSplit },
+              "sidecar: video splits, pure audio moves wholesale")
+
+        var stems: [UUID: (path: String, cacheKey: String, duration: Double)] = [:]
+        for e in plan.entries {
+            stems[e.itemClipId] = ("/tmp/fake.sq/Stems/\(e.stemFile)", "", e.source.sourceLength)
+        }
+        var mig = sm
+        ReaperExport.applyMigration(&mig, plan: plan, stems: stems)
+        check(mig.laneRefs == [.reaper(0), .reaper(1), .video(0), .video(1)],
+              "sidecar: reaper lanes sit above the video lanes")
+        check(mig.clips.first { $0.id == sv.id }?.muted == true,
+              "sidecar: split video muted in place")
+        let moved = mig.clips.first { $0.track == .reaper(1) }
+        check(moved?.id == sa.id && moved?.srcIn == 0 && moved?.reaperGUID != nil
+              && moved?.linkId == nil,
+              "sidecar: audio clip retargets (srcIn reset, GUID set)")
+        check(ReaperExport.exportClips(mig).isEmpty,
+              "sidecar: nothing left to export after migration")
+
+        let blob = try! JSONEncoder().encode(mig)
+        let back = try! JSONDecoder().decode(ProjectModel.self, from: blob)
+        check(back == mig, "sidecar: migrated model round-trips through Codable")
+
+        // Gesture rules, driven through the real event handlers. Lane rows:
+        // reaper(0)=0, reaper(1)=1, video(0)=2, video(1)=3. Reaper lanes are
+        // compact (24 pt) — take y from the real lane geometry, not laneY.
+        store.replaceForTest(mig)
+        DocumentContext.headless.session.snapping = false
+        let sess = DocumentContext.headless.session
+        ReaperLink.reaperRunningOverride = false
+        sess.reaperDirty = false
+        func rowY(_ row: Int) -> CGFloat { timeline.testLaneMidY(row) }
+
+        // Compact + collapsible geometry.
+        check(abs(timeline.testLaneRect(0).height - 24) < 1.5,
+              "sidecar: reaper lanes default to minimum height")
+        sess.reaperCollapsed = true
+        check(timeline.testLaneRect(0).height < 14,
+              "sidecar: collapse shrinks the whole band")
+        sess.reaperCollapsed = false
+
+        // Move the reaper clip (spans 8..20 on lane r1) right by ~6s.
+        drag(from: winPoint(x(12), rowY(1)), to: winPoint(x(18), rowY(1)))
+        check(abs(clip(sa.id)!.start - 14) < 0.5,
+              "sidecar: reaper clip moves horizontally (got \(clip(sa.id)!.start))")
+        check(sess.reaperDirty, "sidecar: the move marks write-back dirty")
+
+        // It can hop between reaper lanes…
+        drag(from: winPoint(x(16), rowY(1)), to: winPoint(x(16), rowY(0)))
+        check(clip(sa.id)!.track == .reaper(0),
+              "sidecar: reaper clip moves across reaper lanes")
+        // …but never off the sidecar onto a video lane.
+        drag(from: winPoint(x(16), rowY(0)), to: winPoint(x(16), rowY(2)))
+        check(clip(sa.id)!.track == .reaper(0),
+              "sidecar: reaper clip can't leave the sidecar")
+
+        // Edge grabs don't trim — they're forced to whole-clip moves.
+        let durBefore = clip(sa.id)!.duration
+        let inEdge = clip(sa.id)!.start
+        drag(from: winPoint(x(inEdge) + 3, rowY(0)), to: winPoint(x(inEdge + 4) + 3, rowY(0)))
+        check(abs(clip(sa.id)!.duration - durBefore) < 0.001,
+              "sidecar: edge drag on a reaper clip moves, never trims")
+
+        // A video clip dragged onto a reaper lane snaps back.
+        let svTrackBefore = clip(sv.id)!.track
+        drag(from: winPoint(x(7), rowY(2)), to: winPoint(x(7), rowY(0)))
+        check(clip(sv.id)!.track == svTrackBefore,
+              "sidecar: video clips can't drop onto reaper lanes")
+
+        // With REAPER open, reaper lanes are read-only.
+        ReaperLink.reaperRunningOverride = true
+        let lockedStart = clip(sa.id)!.start
+        drag(from: winPoint(x(lockedStart + 2), rowY(0)),
+             to: winPoint(x(lockedStart + 8), rowY(0)))
+        check(abs(clip(sa.id)!.start - lockedStart) < 0.001,
+              "sidecar: REAPER open locks the reaper lanes")
+        ReaperLink.reaperRunningOverride = false
+
+        // Delete skips reaper clips (the .rpp owns their existence).
+        store.selection = [sa.id]
+        timeline.deleteSelection()
+        check(clip(sa.id) != nil, "sidecar: delete ignores reaper clips")
+        store.selection = []
+
+        ReaperLink.reaperRunningOverride = nil
+    }
+
+    // 48. Roll edits + overlap-aware edge grabs.
+    do {
+        var rm = ProjectModel()
+        rm.fps = 30
+        var rmedia = MediaItem(path: "/tmp/fake.mov")
+        rmedia.duration = 100
+        rmedia.fps = 30
+        rm.media = [rmedia]
+        rm.tracks = [Track(hue: 0.1), Track(hue: 0.5)]
+        // Two clips butted together at t=40 on track 0 (the roll pair), and an
+        // overlapping pair on track 1 (b1 overlaps a1's tail 45..55).
+        let ra = Clip(mediaId: rmedia.id, track: .video(0), start: 10, srcIn: 0, duration: 30)
+        let rb = Clip(mediaId: rmedia.id, track: .video(0), start: 40, srcIn: 40, duration: 30)
+        let oa = Clip(mediaId: rmedia.id, track: .video(1), start: 20, srcIn: 0, duration: 35)
+        let ob = Clip(mediaId: rmedia.id, track: .video(1), start: 45, srcIn: 50, duration: 30)
+        rm.clips = [ra, rb, oa, ob]
+        store.replaceForTest(rm)
+        DocumentContext.headless.session.snapping = false
+        timeline.zoomToFit()
+
+        // Roll the shared boundary at 40 right by ~10s: ra's end AND rb's
+        // start both land at ~50, rb's srcIn advances, the join stays gapless.
+        drag(from: winPoint(x(40), laneY(0)), to: winPoint(x(50), laneY(0)))
+        var (la, lb) = (clip(ra.id)!, clip(rb.id)!)
+        check(abs(la.end - 50) < 0.5 && abs(lb.start - 50) < 0.5
+              && abs(lb.start - la.end) < 0.001,
+              "roll: boundary 40 → ~50, join stays gapless (got \(la.end), \(lb.start))")
+        check(abs(lb.srcIn - (40 + (lb.start - 40))) < 0.5 && abs(lb.end - 70) < 0.5,
+              "roll: right head trims (srcIn \(lb.srcIn)), right end unmoved")
+        check(abs(la.start - 10) < 0.001, "roll: left start unmoved")
+        store.undo()
+        (la, lb) = (clip(ra.id)!, clip(rb.id)!)
+        check(abs(la.end - 40) < 0.001 && abs(lb.start - 40) < 0.001,
+              "roll: one undo restores both clips")
+
+        // Roll clamps at the right clip's source head: dragging left can only
+        // reveal rb's 40s of pre-roll... which reaches source 0 at t=0, so the
+        // real stop is ra's minimum duration (a frame past its start).
+        drag(from: winPoint(x(40), laneY(0)), to: winPoint(x(2), laneY(0)))
+        (la, lb) = (clip(ra.id)!, clip(rb.id)!)
+        check(la.duration > 0.02 && abs(lb.start - la.end) < 0.001 && lb.srcIn >= -0.001,
+              "roll: clamped left of the boundary (dur \(la.duration), srcIn \(lb.srcIn))")
+        store.undo()
+
+        // ⇧ opts out: one-sided trim of rb's head leaves a gap at the boundary.
+        drag(from: winPoint(x(40) + 3, laneY(0)), to: winPoint(x(50) + 3, laneY(0)),
+             flags: [.shift])
+        (la, lb) = (clip(ra.id)!, clip(rb.id)!)
+        check(abs(la.end - 40) < 0.001 && lb.start > 48,
+              "roll: ⇧-drag opts out to a one-sided trim (gap ok)")
+        store.undo()
+
+        // Overlap-aware handles: oa's out edge (55) lies INSIDE ob's body —
+        // grabbing it must trim oa, not select-both-and-move. ob is on top
+        // (later start), so without edge priority this drags the pair.
+        drag(from: winPoint(x(55) - 3, laneY(1)), to: winPoint(x(48) - 3, laneY(1)))
+        let (poa, pob) = (clip(oa.id)!, clip(ob.id)!)
+        check(abs(poa.end - 48) < 0.5, "overlap: buried out-handle trims its owner")
+        check(abs(pob.start - 45) < 0.001 && abs(pob.end - 75) < 0.001,
+              "overlap: the top clip doesn't move or resize (got \(pob.start)..\(pob.end))")
+        store.undo()
+
+        // A body click inside the overlap still selects both offenders.
+        drag(from: winPoint(x(50), laneY(1)), to: winPoint(x(50), laneY(1)), steps: 1)
+        check(store.selection == [oa.id, ob.id],
+              "overlap: body click still selects both offenders")
+        store.selection = []
+    }
+
     print(failures == 0 ? "\nALL PASS" : "\n\(failures) FAILURES")
     exit(failures == 0 ? 0 : 1)
 }
diff --git a/sequencer/Sources/Sequencer/ViewerGridView.swift b/sequencer/Sources/Sequencer/ViewerGridView.swift
index a609d9124d20ff27b39def38e92123c2f042390b..ded74e1ca16c14c399d4bec6b220a331b5e1c981 100644
--- a/sequencer/Sources/Sequencer/ViewerGridView.swift
+++ b/sequencer/Sources/Sequencer/ViewerGridView.swift
@@ -136,17 +136,15 @@ final class ViewerGridView: NSView {
     /// Tracks whose previews should show right now: visible (hide/focus) AND
     /// something VISUAL is under the playhead (audio clips never get a cell).
     private func activeTracks() -> [TrackRef] {
-        let project = store.project
         let playhead = playback.playhead
         let focusActive = !session.focusedTracks.isEmpty || session.fusionFocus
-        return project.laneRefs.filter { ref in
+        let index = store.index
+        return index.laneRefs.filter { ref in
             let visible = focusActive ? session.focusedTracks.contains(ref)
                                       : !session.hiddenTracks.contains(ref)
             guard visible else { return false }
-            return project.clips.contains {
-                $0.track == ref && $0.kind != .audio
-                    && playhead >= $0.start && playhead < $0.end
-            }
+            return index.clipAt(track: ref, time: playhead, kind: .video) != nil
+                || index.clipAt(track: ref, time: playhead, kind: .storyboard) != nil
         }
     }
 
@@ -154,14 +152,14 @@ final class ViewerGridView: NSView {
     /// AR — videos are never inward-cropped).
     private func paneAspect(_ ref: TrackRef) -> CGFloat {
         if ref == Self.fusionKey { return 16.0 / 9.0 }
-        let project = store.project
+        let index = store.index
         let t = playback.playhead
-        if let clip = project.clipAt(track: ref, time: t, kind: .storyboard),
+        if let clip = index.clipAt(track: ref, time: t, kind: .storyboard),
            let b = clip.board, b.height > 0 {
             return CGFloat(b.width / b.height)
         }
-        if let clip = project.clipAt(track: ref, time: t, kind: .video),
-           let m = project.media(clip.mediaId), m.width > 0, m.height > 0 {
+        if let clip = index.clipAt(track: ref, time: t, kind: .video),
+           let m = index.media(clip.mediaId), m.width > 0, m.height > 0 {
             return CGFloat(m.width) / CGFloat(m.height)
         }
         return 16.0 / 9.0
@@ -1072,6 +1070,12 @@ final class ViewerCell: ViewerCellBase {
 
     private var currentClipId: UUID?
 
+    /// What the live player layer last revealed (media + source time) — a
+    /// settling seek that lands near it holds the layer instead of flashing
+    /// a low-res stand-in. Updated only on an `itemOK` reveal.
+    private var lastShownKey: String?
+    private var lastShownSrc: Double = -1
+
     // MARK: Drawing directly on storyboard previews
 
     private var strokeBoard: Board?
@@ -1079,10 +1083,7 @@ final class ViewerCell: ViewerCellBase {
 
     /// The storyboard panel this cell is currently showing, if any.
     private var panelClip: Clip? {
-        let project = store.project
-        return project.clipAt(track: ref,
-                              time: playback.playhead,
-                              kind: .storyboard)
+        store.index.clipAt(track: ref, time: playback.playhead, kind: .storyboard)
     }
 
     /// View point → board coords through the aspect-fill crop.
@@ -1294,7 +1295,7 @@ final class ViewerCell: ViewerCellBase {
         CATransaction.begin()
         CATransaction.setDisableActions(true)
         defer { CATransaction.commit() }
-        let project = store.project
+        let index = store.index
         let playhead = playback.playhead
         // Double-buffered: bind each layer to its sub-player once, then show only
         // the front buffer's layer. The back buffer (a prerolled upcoming clip)
@@ -1311,21 +1312,21 @@ final class ViewerCell: ViewerCellBase {
 
         // Storyboard panels preview their composite (and take strokes). Their
         // "1B" name lives top-left like a filename, and stays visible.
-        if let panel = project.clipAt(track: ref, time: playhead, kind: .storyboard),
+        if let panel = index.clipAt(track: ref, time: playhead, kind: .storyboard),
            let board = panel.board {
             currentClipId = panel.id
             frontLayer.isHidden = true
             imageLayer.isHidden = false
             imageLayer.contents = boards.composite(for: board)
-            setTopLeft(project.panelNames()[panel.id] ?? "", hoverOnly: false)
+            setTopLeft(store.project.panelNames()[panel.id] ?? "", hoverOnly: false)
             setStatus("")
             cancelLoadingOverlay()
             return
         }
 
         // Audio never shows here — cells exist only for visual tracks.
-        guard let clip = project.clipAt(track: ref, time: playhead, kind: .video),
-              let media = project.media(clip.mediaId) else {
+        guard let clip = index.clipAt(track: ref, time: playhead, kind: .video),
+              let media = index.media(clip.mediaId) else {
             currentClipId = nil
             frontLayer.isHidden = true
             imageLayer.isHidden = true
@@ -1346,8 +1347,17 @@ final class ViewerCell: ViewerCellBase {
         // parked near the expected source time; otherwise the filmstrip (a
         // real frame at this moment) stands in — so the transition is
         // filmstrip → video, never black.
-        let cur = front.player.currentTime().seconds
-        let onTime = cur.isFinite && abs(cur - src) < 0.5
+        //
+        // And not just parked: SETTLED. `currentTime()` updates the instant a
+        // seek completes, but the layer keeps PRESENTING the previous decoded
+        // picture until the new frame lands — trusting the time there flashed
+        // the frame the user scrubbed FROM (visibly "an earlier part of the
+        // video"). While settling, hold the stand-in. (The settle check also
+        // skips the currentTime read right after an install, which would
+        // block main on the busy player queue.)
+        let settled = playback.rate != 0 || !front.isSettling
+        let cur = settled ? (front.playedSeconds ?? -1) : -1
+        let onTime = settled && cur.isFinite && abs(cur - src) < 0.5
         let itemOK = front.player.currentItem != nil && !front.itemFailed
             && front.player.currentItem?.status != .failed
             && (covered || chunks.originalPlayable(media: media))
@@ -1362,10 +1372,27 @@ final class ViewerCell: ViewerCellBase {
             FrameCache.shared.warm(mediaKey: media.cacheKey, at: src,
                                    source: chunks.frameSource(media: media, sourceTime: src))
         }
+        // A settling seek that stays NEAR the frame already on screen (a frame
+        // step, a nudge, a slow scrub) holds the live layer: the presented
+        // picture is at most a beat stale and visually continuous, where
+        // swapping to a 240px thumb for the couple of ticks the seek needs
+        // reads as a brief low-res flash. Long jumps still swap to a stand-in
+        // — holding across those shows an unrelated frame (the old scrub-flash
+        // bug). Never hold across an item install: the fresh item may present
+        // nothing (black) or frame 0.
+        if !itemOK, !frontLayer.isHidden, !front.recentlyInstalled,
+           front.player.currentItem != nil, !front.itemFailed,
+           lastShownKey == media.cacheKey, abs(src - lastShownSrc) < 0.6 {
+            cancelLoadingOverlay()
+            setStatus(status)
+            return
+        }
         if itemOK {
             frontLayer.isHidden = false
             imageLayer.isHidden = true
             cancelLoadingOverlay()
+            lastShownKey = media.cacheKey
+            lastShownSrc = src
         } else if let frame = FrameCache.shared.image(media: media, at: src) {
             // The RAM frame cache has the exact (full-quality) frame for this
             // moment — a warmed cut boundary, or a stand-in decoded on demand
@@ -1376,11 +1403,17 @@ final class ViewerCell: ViewerCellBase {
             imageLayer.contents = frame
             cancelLoadingOverlay()
             if MediaPipeline.shared.isOffline(media) { status = "offline" }
-        } else if let strip = MediaPipeline.shared.filmstripImage(for: media, at: src) {
-            // A filmstrip is a real frame for this moment: stand in with it so
-            // the transition is filmstrip → video, never black. If the original
-            // is offline the cached strip still previews, but flag it in the
-            // corner so it's clear playback/export won't work until it's back.
+        } else if let strip = MediaPipeline.shared.fineThumbImage(for: media, at: src)
+                    ?? MediaPipeline.shared.filmstripImage(for: media, at: src,
+                                                           maxDistance: 2.5) {
+            // A thumbnail NEAR this moment stands in so the transition is
+            // thumb → video, never black. Fine thumbs (0.5s grid) first; the
+            // coarse strip is keyframe-anchored, and on long-GOP screen
+            // recordings the nearest keyframe can be tens of seconds away —
+            // an UNRELATED frame, worse than holding the last picture — so a
+            // coarse thumb only stands in when it's actually close. If the
+            // original is offline the cached thumb still previews, but flag it
+            // in the corner so it's clear playback/export won't work.
             frontLayer.isHidden = true
             imageLayer.isHidden = false
             imageLayer.contents = strip
diff --git a/sequencer/Sources/Sequencer/WindowController.swift b/sequencer/Sources/Sequencer/WindowController.swift
index f7f77ca8500d041656517e6f492666e834bd89eb..89e4cf0c58a3b2a07a754e3b12be7241987a7eaa 100644
--- a/sequencer/Sources/Sequencer/WindowController.swift
+++ b/sequencer/Sources/Sequencer/WindowController.swift
@@ -1,184 +1,32 @@
 import AppKit
 import UniformTypeIdentifiers
 
-/// One window per open project. Owns the timeline / viewer / transport views
-/// (all bound to this document's `ctx`), the split layout, and every
-/// per-document menu action. Menu items for these actions target the first
-/// responder, so the key window's controller handles them.
-final class SequencerWindowController: NSWindowController, NSWindowDelegate,
-                                       NSSplitViewDelegate, NSMenuItemValidation {
+/// Base controller for any window that hosts a `TimelineView` bound to a
+/// document. Owns the per-document menu actions (`@objc`s targeting the first
+/// responder) so they route to whichever timeline window is key: each action
+/// operates on *this* controller's `timeline` (its own zoom/scroll) and the
+/// shared `ctx` (playhead, selection, model), which is exactly what a second
+/// view onto the same timeline wants.
+///
+/// `SequencerWindowController` is the full document window (viewer + transport +
+/// split + previews). `TimelineWindowController` is a lightweight extra view —
+/// a second zoom/scroll onto the same timeline (View ▸ New Timeline Window).
+class TimelineHostWindowController: NSWindowController, NSMenuItemValidation {
     let ctx: DocumentContext
     let timeline = TimelineView()
-    let viewer = ViewerGridView()
-    let transport = TransportBar()
-    private let split = NSSplitView()
-    private let container = NSView()
-    private let timelinePane = NSView()
-    private var popoutWindow: NSWindow?
-    private var previewsPopped = false
-    var previewsArePopped: Bool { previewsPopped }
-    private var layoutConstraints: [NSLayoutConstraint] = []
 
-    private var session: SessionState { ctx.session }
-    private var store: Store { ctx.store }
-    private var fps: Double { ctx.store.project.fps }
+    var session: SessionState { ctx.session }
+    var store: Store { ctx.store }
+    var fps: Double { ctx.store.project.fps }
 
-    init(ctx: DocumentContext) {
+    init(ctx: DocumentContext, window: NSWindow) {
         self.ctx = ctx
-        let window = NSWindow(
-            contentRect: NSRect(x: 0, y: 0, width: 1500, height: 950),
-            styleMask: [.titled, .closable, .miniaturizable, .resizable],
-            backing: .buffered, defer: false)
-        window.minSize = NSSize(width: 900, height: 600)
         super.init(window: window)
-        window.delegate = self
-        shouldCascadeWindows = true
-
-        // Bind the three views to this document's context before they draw.
+        // Bind the timeline to this document's context before it draws.
         timeline.ctx = ctx
-        viewer.ctx = ctx
-        transport.ctx = ctx
-
-        buildContent()
-        window.makeFirstResponder(timeline)
     }
     required init?(coder: NSCoder) { fatalError() }
 
-    /// Warm up derived assets and start the playback clock once the document is
-    /// loaded and its window shown.
-    func startDocumentServices() {
-        ctx.startServices()
-    }
-
-    // MARK: - Window & layout
-
-    private func buildContent() {
-        transport.translatesAutoresizingMaskIntoConstraints = false
-        timeline.translatesAutoresizingMaskIntoConstraints = false
-        split.dividerStyle = .thin
-        split.delegate = self
-        split.translatesAutoresizingMaskIntoConstraints = false
-
-        timelinePane.addSubview(timeline)
-        container.addSubview(split)
-        NSLayoutConstraint.activate([
-            timeline.leadingAnchor.constraint(equalTo: timelinePane.leadingAnchor),
-            timeline.trailingAnchor.constraint(equalTo: timelinePane.trailingAnchor),
-            timeline.bottomAnchor.constraint(equalTo: timelinePane.bottomAnchor),
-            split.leadingAnchor.constraint(equalTo: container.leadingAnchor),
-            split.trailingAnchor.constraint(equalTo: container.trailingAnchor),
-            split.bottomAnchor.constraint(equalTo: container.bottomAnchor),
-        ])
-        window?.contentView = container
-        applyLayout()
-    }
-
-    // Neither pane may collapse: previews and timeline both stay usable.
-    func splitView(_ splitView: NSSplitView, constrainMinCoordinate proposed: CGFloat,
-                   ofSubviewAt dividerIndex: Int) -> CGFloat {
-        max(proposed, 200)
-    }
-    func splitView(_ splitView: NSSplitView, constrainMaxCoordinate proposed: CGFloat,
-                   ofSubviewAt dividerIndex: Int) -> CGFloat {
-        let total = splitView.isVertical ? splitView.bounds.width : splitView.bounds.height
-        return min(proposed, total - 240)
-    }
-
-    /// Rebuild the split for the current layout mode: previews above (default),
-    /// previews on the left, or previews popped out into their own window.
-    private func applyLayout() {
-        guard let window else { return }
-        viewer.removeFromSuperview()
-        for v in split.arrangedSubviews {
-            split.removeArrangedSubview(v)
-            v.removeFromSuperview()
-        }
-        NSLayoutConstraint.deactivate(layoutConstraints)
-        transport.removeFromSuperview()
-
-        let toolbarOnTop = previewsPopped || session.previewsOnLeft
-        if toolbarOnTop {
-            container.addSubview(transport)
-            layoutConstraints = [
-                transport.topAnchor.constraint(equalTo: container.topAnchor),
-                transport.leadingAnchor.constraint(equalTo: container.leadingAnchor),
-                transport.trailingAnchor.constraint(equalTo: container.trailingAnchor),
-                transport.heightAnchor.constraint(equalToConstant: 27),
-                split.topAnchor.constraint(equalTo: transport.bottomAnchor),
-                timeline.topAnchor.constraint(equalTo: timelinePane.topAnchor),
-            ]
-        } else {
-            timelinePane.addSubview(transport)
-            layoutConstraints = [
-                transport.topAnchor.constraint(equalTo: timelinePane.topAnchor),
-                transport.leadingAnchor.constraint(equalTo: timelinePane.leadingAnchor),
-                transport.trailingAnchor.constraint(equalTo: timelinePane.trailingAnchor),
-                transport.heightAnchor.constraint(equalToConstant: 27),
-                split.topAnchor.constraint(equalTo: container.topAnchor),
-                timeline.topAnchor.constraint(equalTo: transport.bottomAnchor),
-            ]
-        }
-        NSLayoutConstraint.activate(layoutConstraints)
-
-        if previewsPopped {
-            let pw = popoutWindow ?? {
-                let w = NSWindow(
-                    contentRect: NSRect(x: 0, y: 0, width: 960, height: 560),
-                    styleMask: [.titled, .closable, .resizable],
-                    backing: .buffered, defer: false)
-                w.title = "Previews"
-                w.isReleasedWhenClosed = false
-                w.delegate = self
-                popoutWindow = w
-                return w
-            }()
-            pw.contentView = viewer
-            pw.makeKeyAndOrderFront(nil)
-            split.isVertical = false
-            split.addArrangedSubview(timelinePane)
-            window.makeKeyAndOrderFront(nil)
-        } else {
-            if let pw = popoutWindow {
-                pw.delegate = nil
-                pw.contentView = NSView()
-                pw.orderOut(nil)
-                pw.delegate = self
-            }
-            split.isVertical = session.previewsOnLeft
-            split.addArrangedSubview(viewer)
-            split.addArrangedSubview(timelinePane)
-            split.setHoldingPriority(.defaultLow, forSubviewAt: 0)
-            split.setHoldingPriority(.defaultHigh, forSubviewAt: 1)
-            DispatchQueue.main.async { [self] in
-                if session.previewsOnLeft {
-                    split.setPosition(window.frame.width * 0.44, ofDividerAt: 0)
-                } else {
-                    split.setPosition(window.frame.height * 0.62, ofDividerAt: 0)
-                }
-            }
-        }
-        window.makeFirstResponder(timeline)
-    }
-
-    func windowWillClose(_ notification: Notification) {
-        if (notification.object as? NSWindow) === popoutWindow, previewsPopped {
-            previewsPopped = false
-            applyLayout()
-        }
-    }
-
-    /// This project became frontmost — now (and only now) kick the whole-project
-    /// proxy pre-build so scrubbing anywhere is smooth. Deferring the fill to here
-    /// rather than document load is what stops state-restored *background* projects
-    /// from all transcoding their full proxy sets at once and overflowing the
-    /// shared cache (see DocumentContext.startServices). `ensure` is idempotent —
-    /// already-built chunks are skipped — so re-focusing a project is essentially
-    /// free. Ignore the popout window becoming main (it shares this ctx).
-    func windowDidBecomeMain(_ notification: Notification) {
-        guard (notification.object as? NSWindow) === window else { return }
-        ctx.chunks.ensure(for: ctx.store.project)
-    }
-
     // MARK: - Menu validation (per-document items)
 
     func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
@@ -198,12 +46,6 @@ final class SequencerWindowController: NSWindowController, NSWindowDelegate,
         case #selector(toggleFilmstrips):
             menuItem.state = session.showFilmstrips ? .on : .off
             return true
-        case #selector(togglePreviewsLeft):
-            menuItem.state = session.previewsOnLeft ? .on : .off
-            return !previewsPopped
-        case #selector(togglePopout):
-            menuItem.state = previewsPopped ? .on : .off
-            return true
         case #selector(openStoryboardEditor):
             return session.panelUnderPlayhead != nil ||
                 store.selection.contains { store.project.clip($0)?.kind == .storyboard }
@@ -217,6 +59,8 @@ final class SequencerWindowController: NSWindowController, NSWindowDelegate,
             return true
         case #selector(clearInOut):
             return ctx.playback.hasInOut
+        case #selector(openInReaper):
+            return store.project.hasReaper
         default: return true
         }
     }
@@ -233,6 +77,8 @@ final class SequencerWindowController: NSWindowController, NSWindowDelegate,
     }
     @objc func rippleTrimLeft() { timeline.rippleTrimToPlayhead(deleteLeft: true) }
     @objc func rippleTrimRight() { timeline.rippleTrimToPlayhead(deleteLeft: false) }
+    @objc func deleteLeft() { timeline.rippleTrimToPlayhead(deleteLeft: true, ripple: false) }
+    @objc func deleteRight() { timeline.rippleTrimToPlayhead(deleteLeft: false, ripple: false) }
     @objc func closeGapAtPlayhead() { timeline.closeBlankSpaceAtPlayhead() }
     @objc func split(_ sender: Any?) { timeline.split() }
     @objc func splitStoryboard() { timeline.splitStoryboardAtPlayhead() }
@@ -244,6 +90,33 @@ final class SequencerWindowController: NSWindowController, NSWindowDelegate,
     @objc func nudgeLeftSecond() { timeline.nudgeSelection(by: -1) }
     @objc func nudgeRightSecond() { timeline.nudgeSelection(by: 1) }
     @objc func showExport() { ExportDialog.shared.show() }
+    @objc func exportReaper() {
+        guard ctx.document?.fileURL != nil else {
+            let a = NSAlert()
+            a.messageText = "Save the project first"
+            a.informativeText = ReaperExport.ReaperError.notSaved.errorDescription ?? ""
+            a.runModal()
+            return
+        }
+        let hud = ExportProgressHUD()
+        hud.begin(title: "Exporting to REAPER…")
+        ReaperExport.run(ctx: ctx, progress: { [hud] f in hud.setFraction(f) }) { [hud] result in
+            hud.end()
+            switch result {
+            case .success(let url):
+                NotificationCenter.default.post(name: .transientStatus, object: nil,
+                    userInfo: ["text": "Clips moved to REAPER lanes — opening \(url.lastPathComponent)…"])
+                // Launch the freshly-written project in REAPER straight away.
+                NSWorkspace.shared.open(url)
+            case .failure(let err):
+                let a = NSAlert()
+                a.messageText = "REAPER export failed"
+                a.informativeText = (err as? LocalizedError)?.errorDescription ?? "\(err)"
+                a.alertStyle = .warning
+                a.runModal()
+            }
+        }
+    }
     @objc func muteClips() { timeline.toggleMute() }
     @objc func linkClips() { timeline.linkSelection() }
     @objc func unlinkClips() { timeline.unlinkSelection() }
@@ -270,6 +143,11 @@ final class SequencerWindowController: NSWindowController, NSWindowDelegate,
         }
     }
 
+    /// Hand the sidecar `.rpp` to REAPER (flushing any pending sequencer-side
+    /// reaper-lane moves first). Also reachable by double-clicking any green
+    /// reaper clip.
+    @objc func openInReaper() { ReaperLink.openInReaper(ctx) }
+
     // MARK: - Track actions
 
     @objc func deleteEmptyTracks() { timeline.deleteEmptyTracks() }
@@ -288,13 +166,15 @@ final class SequencerWindowController: NSWindowController, NSWindowDelegate,
         session.laneScale = 1
         session.trackHeights = [:]
     }
-    @objc func togglePreviewsLeft() {
-        session.previewsOnLeft.toggle()
-        applyLayout()
-    }
-    @objc func togglePopout() {
-        previewsPopped.toggle()
-        applyLayout()
+
+    /// Open another timeline window onto this same document — its own zoom and
+    /// scroll, sharing the playhead / selection / tracks. Routes to the owning
+    /// document window controller (which owns the secondary windows' lifecycle)
+    /// so this works whether the main window or a secondary window is key.
+    @objc func newTimelineWindow() {
+        ctx.document?.windowControllers
+            .compactMap { $0 as? SequencerWindowController }
+            .first?.openSecondaryTimeline()
     }
 
     // MARK: - Playback actions
@@ -338,3 +218,331 @@ final class SequencerWindowController: NSWindowController, NSWindowDelegate,
         }
     }
 }
+
+/// One main window per open project. Owns the timeline / viewer / transport views
+/// (all bound to this document's `ctx`), the split layout, the previews pop-out,
+/// and any extra timeline windows spawned onto this document.
+final class SequencerWindowController: TimelineHostWindowController, NSWindowDelegate,
+                                       NSSplitViewDelegate {
+    let viewer = ViewerGridView()
+    let transport = TransportBar()
+    private let split = NSSplitView()
+    private let container = NSView()
+    private let timelinePane = NSView()
+    private var popoutWindow: NSWindow?
+    private var previewsPopped = false
+    var previewsArePopped: Bool { previewsPopped }
+    private var layoutConstraints: [NSLayoutConstraint] = []
+
+    /// Extra timeline windows onto this same document (View ▸ New Timeline
+    /// Window). Owned here — not added as NSDocument window controllers, which
+    /// would block document close until every one was shut. Torn down when this
+    /// main window closes (windowWillClose), before `ctx` is deallocated.
+    private var secondaryTimelines: [TimelineWindowController] = []
+
+    /// REAPER sidecar sync triggers (removed in windowWillClose):
+    /// re-activating the app doesn't re-fire windowDidBecomeMain, so the
+    /// return-from-REAPER pull needs its own hook; and REAPER *launching* is
+    /// the last safe moment to flush pending reaper-lane moves.
+    private var reaperObservers: [NSObjectProtocol] = []
+
+    init(ctx: DocumentContext) {
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 1500, height: 950),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered, defer: false)
+        window.minSize = NSSize(width: 900, height: 600)
+        super.init(ctx: ctx, window: window)
+        window.delegate = self
+        shouldCascadeWindows = true
+
+        // Bind the two remaining views to this document's context before they draw.
+        viewer.ctx = ctx
+        transport.ctx = ctx
+
+        buildContent()
+        window.makeFirstResponder(timeline)
+
+        reaperObservers.append(NotificationCenter.default.addObserver(
+            forName: NSApplication.didBecomeActiveNotification, object: nil, queue: .main
+        ) { [weak self] _ in
+            guard let self, self.window?.isMainWindow == true else { return }
+            ReaperLink.pull(self.ctx)
+        })
+        reaperObservers.append(NSWorkspace.shared.notificationCenter.addObserver(
+            forName: NSWorkspace.didLaunchApplicationNotification, object: nil, queue: .main
+        ) { [weak self] note in
+            guard let self,
+                  let app = note.userInfo?[NSWorkspace.applicationUserInfoKey]
+                      as? NSRunningApplication,
+                  app.bundleIdentifier == ReaperLink.reaperBundleId else { return }
+            ReaperLink.push(self.ctx)
+        })
+    }
+    required init?(coder: NSCoder) { fatalError() }
+
+    /// Warm up derived assets and start the playback clock once the document is
+    /// loaded and its window shown.
+    func startDocumentServices() {
+        ctx.startServices()
+    }
+
+    // MARK: - Window & layout
+
+    private func buildContent() {
+        transport.translatesAutoresizingMaskIntoConstraints = false
+        timeline.translatesAutoresizingMaskIntoConstraints = false
+        split.dividerStyle = .thin
+        split.delegate = self
+        split.translatesAutoresizingMaskIntoConstraints = false
+
+        timelinePane.addSubview(timeline)
+        container.addSubview(split)
+        NSLayoutConstraint.activate([
+            timeline.leadingAnchor.constraint(equalTo: timelinePane.leadingAnchor),
+            timeline.trailingAnchor.constraint(equalTo: timelinePane.trailingAnchor),
+            timeline.bottomAnchor.constraint(equalTo: timelinePane.bottomAnchor),
+            split.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            split.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            split.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+        ])
+        window?.contentView = container
+        applyLayout()
+    }
+
+    // Neither pane may collapse: previews and timeline both stay usable.
+    func splitView(_ splitView: NSSplitView, constrainMinCoordinate proposed: CGFloat,
+                   ofSubviewAt dividerIndex: Int) -> CGFloat {
+        max(proposed, 200)
+    }
+    func splitView(_ splitView: NSSplitView, constrainMaxCoordinate proposed: CGFloat,
+                   ofSubviewAt dividerIndex: Int) -> CGFloat {
+        let total = splitView.isVertical ? splitView.bounds.width : splitView.bounds.height
+        return min(proposed, total - 240)
+    }
+
+    /// Rebuild the split for the current layout mode: previews above (default),
+    /// previews on the left, or previews popped out into their own window.
+    private func applyLayout() {
+        guard let window else { return }
+        viewer.removeFromSuperview()
+        for v in split.arrangedSubviews {
+            split.removeArrangedSubview(v)
+            v.removeFromSuperview()
+        }
+        NSLayoutConstraint.deactivate(layoutConstraints)
+        transport.removeFromSuperview()
+
+        let toolbarOnTop = previewsPopped || session.previewsOnLeft
+        if toolbarOnTop {
+            container.addSubview(transport)
+            layoutConstraints = [
+                transport.topAnchor.constraint(equalTo: container.topAnchor),
+                transport.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+                transport.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+                transport.heightAnchor.constraint(equalToConstant: 27),
+                split.topAnchor.constraint(equalTo: transport.bottomAnchor),
+                timeline.topAnchor.constraint(equalTo: timelinePane.topAnchor),
+            ]
+        } else {
+            timelinePane.addSubview(transport)
+            layoutConstraints = [
+                transport.topAnchor.constraint(equalTo: timelinePane.topAnchor),
+                transport.leadingAnchor.constraint(equalTo: timelinePane.leadingAnchor),
+                transport.trailingAnchor.constraint(equalTo: timelinePane.trailingAnchor),
+                transport.heightAnchor.constraint(equalToConstant: 27),
+                split.topAnchor.constraint(equalTo: container.topAnchor),
+                timeline.topAnchor.constraint(equalTo: transport.bottomAnchor),
+            ]
+        }
+        NSLayoutConstraint.activate(layoutConstraints)
+
+        if previewsPopped {
+            let pw = popoutWindow ?? {
+                let w = NSWindow(
+                    contentRect: NSRect(x: 0, y: 0, width: 960, height: 560),
+                    styleMask: [.titled, .closable, .resizable],
+                    backing: .buffered, defer: false)
+                w.title = "Previews"
+                w.isReleasedWhenClosed = false
+                w.delegate = self
+                popoutWindow = w
+                return w
+            }()
+            pw.contentView = viewer
+            pw.makeKeyAndOrderFront(nil)
+            split.isVertical = false
+            split.addArrangedSubview(timelinePane)
+            window.makeKeyAndOrderFront(nil)
+        } else {
+            if let pw = popoutWindow {
+                pw.delegate = nil
+                pw.contentView = NSView()
+                pw.orderOut(nil)
+                pw.delegate = self
+            }
+            split.isVertical = session.previewsOnLeft
+            split.addArrangedSubview(viewer)
+            split.addArrangedSubview(timelinePane)
+            split.setHoldingPriority(.defaultLow, forSubviewAt: 0)
+            split.setHoldingPriority(.defaultHigh, forSubviewAt: 1)
+            DispatchQueue.main.async { [self] in
+                if session.previewsOnLeft {
+                    split.setPosition(window.frame.width * 0.44, ofDividerAt: 0)
+                } else {
+                    split.setPosition(window.frame.height * 0.62, ofDividerAt: 0)
+                }
+            }
+        }
+        window.makeFirstResponder(timeline)
+    }
+
+    // MARK: - Secondary timeline windows
+
+    /// Spin up another timeline view onto this document: its own window with an
+    /// independent zoom/scroll but the same playhead, selection, tracks, and
+    /// track heights (all shared via `ctx`/`session`).
+    func openSecondaryTimeline() {
+        let name = ctx.document?.displayName ?? "Timeline"
+        // Number sequentially by how many are already open; the count never
+        // reuses a lower slot mid-session, so titles stay distinct enough.
+        let n = secondaryTimelines.count + 2
+        let wc = TimelineWindowController(ctx: ctx, title: "\(name) — Timeline \(n)")
+        secondaryTimelines.append(wc)
+        wc.showWindow(nil)
+    }
+
+    /// A secondary window closed itself — drop it so its controller/window can
+    /// deallocate. Called by `TimelineWindowController.windowWillClose`.
+    func secondaryTimelineDidClose(_ wc: TimelineWindowController) {
+        secondaryTimelines.removeAll { $0 === wc }
+    }
+
+    func windowWillClose(_ notification: Notification) {
+        let obj = notification.object as? NSWindow
+        if obj === popoutWindow, previewsPopped {
+            previewsPopped = false
+            applyLayout()
+            return
+        }
+        // The main window is closing (→ document close → ctx teardown). Every
+        // extra timeline window holds an `unowned ctx`, so close them now, before
+        // the context is gone, or a late redraw would trap on a dangling ref.
+        if obj === window {
+            ReaperLink.push(ctx)
+            if let o = reaperObservers.first { NotificationCenter.default.removeObserver(o) }
+            if reaperObservers.count > 1 {
+                NSWorkspace.shared.notificationCenter.removeObserver(reaperObservers[1])
+            }
+            reaperObservers.removeAll()
+            for wc in secondaryTimelines { wc.close() }
+            secondaryTimelines.removeAll()
+        }
+    }
+
+    /// This project became frontmost — now (and only now) kick the whole-project
+    /// proxy pre-build so scrubbing anywhere is smooth. Deferring the fill to here
+    /// rather than document load is what stops state-restored *background* projects
+    /// from all transcoding their full proxy sets at once and overflowing the
+    /// shared cache (see DocumentContext.startServices). `ensure` is idempotent —
+    /// already-built chunks are skipped — so re-focusing a project is essentially
+    /// free. Ignore the popout window becoming main (it shares this ctx);
+    /// secondary timeline windows have their own controller, so they never
+    /// reach here.
+    func windowDidBecomeMain(_ notification: Notification) {
+        guard (notification.object as? NSWindow) === window else { return }
+        ctx.chunks.ensure(for: ctx.store.project)
+        // Focus edge = the moment the .rpp may have changed under us (the user
+        // was just in REAPER). mtime-gated, so refocusing is nearly free.
+        ReaperLink.pull(ctx)
+    }
+
+    /// Losing key = the user is heading somewhere else (possibly REAPER) —
+    /// flush any sequencer-side reaper-lane moves into the .rpp now, while we
+    /// still know REAPER hasn't opened it.
+    func windowDidResignKey(_ notification: Notification) {
+        guard (notification.object as? NSWindow) === window else { return }
+        ReaperLink.push(ctx)
+    }
+
+    // MARK: - Menu validation (previews/popout — the rest live on the base)
+
+    override func validateMenuItem(_ menuItem: NSMenuItem) -> Bool {
+        switch menuItem.action {
+        case #selector(togglePreviewsLeft):
+            menuItem.state = session.previewsOnLeft ? .on : .off
+            return !previewsPopped
+        case #selector(togglePopout):
+            menuItem.state = previewsPopped ? .on : .off
+            return true
+        default: return super.validateMenuItem(menuItem)
+        }
+    }
+
+    // MARK: - Previews / popout actions (main window only)
+
+    @objc func togglePreviewsLeft() {
+        session.previewsOnLeft.toggle()
+        applyLayout()
+    }
+    @objc func togglePopout() {
+        previewsPopped.toggle()
+        applyLayout()
+    }
+}
+
+/// A lightweight extra window that is a **second view onto the same timeline** —
+/// its own zoom and scroll, sharing the document's playhead, selection, tracks,
+/// and track heights. No viewer, but it carries its own transport toolbar (bound
+/// to the same `ctx`, so tools/snapping/height/timecode all track the document).
+/// Owned (in a list) by the `SequencerWindowController` that spawned it and torn
+/// down when that main window closes.
+final class TimelineWindowController: TimelineHostWindowController, NSWindowDelegate {
+    private let transport = TransportBar()
+
+    init(ctx: DocumentContext, title: String) {
+        let window = NSWindow(
+            contentRect: NSRect(x: 0, y: 0, width: 1200, height: 400),
+            styleMask: [.titled, .closable, .miniaturizable, .resizable],
+            backing: .buffered, defer: false)
+        window.minSize = NSSize(width: 500, height: 200)
+        window.title = title
+        window.isReleasedWhenClosed = false
+        super.init(ctx: ctx, window: window)
+        window.delegate = self
+        shouldCascadeWindows = true
+        transport.ctx = ctx
+
+        // This is an additional view — it must not fight the main timeline over
+        // the proxy builder's "what the user can see" heat anchor.
+        timeline.isSecondary = true
+
+        let container = NSView()
+        transport.translatesAutoresizingMaskIntoConstraints = false
+        timeline.translatesAutoresizingMaskIntoConstraints = false
+        container.addSubview(transport)
+        container.addSubview(timeline)
+        NSLayoutConstraint.activate([
+            transport.topAnchor.constraint(equalTo: container.topAnchor),
+            transport.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            transport.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            transport.heightAnchor.constraint(equalToConstant: 27),
+            timeline.topAnchor.constraint(equalTo: transport.bottomAnchor),
+            timeline.leadingAnchor.constraint(equalTo: container.leadingAnchor),
+            timeline.trailingAnchor.constraint(equalTo: container.trailingAnchor),
+            timeline.bottomAnchor.constraint(equalTo: container.bottomAnchor),
+        ])
+        window.contentView = container
+        window.makeFirstResponder(timeline)
+        // Frame the whole project once the view has real bounds.
+        DispatchQueue.main.async { [weak self] in self?.timeline.zoomToFit() }
+    }
+    required init?(coder: NSCoder) { fatalError() }
+
+    func windowWillClose(_ notification: Notification) {
+        guard (notification.object as? NSWindow) === window else { return }
+        ctx.document?.windowControllers
+            .compactMap { $0 as? SequencerWindowController }
+            .first?.secondaryTimelineDidClose(self)
+    }
+}
diff --git a/sequencer/Sources/Sequencer/main.swift b/sequencer/Sources/Sequencer/main.swift
index bae0c79178aeb475bd2929d0855e3f2616607df6..0eb7a13838ceca9a92792beb8b2c8162b27c9489 100644
--- a/sequencer/Sources/Sequencer/main.swift
+++ b/sequencer/Sources/Sequencer/main.swift
@@ -13,6 +13,36 @@ if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--cachetest" {
     exit(0)
 }
 
+// Headless RPP parser round-trip test: sequencer --rpptest <file.rpp>
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--rpptest" {
+    runRppTest(path: CommandLine.arguments[2])
+    exit(0)
+}
+
+// Headless REAPER-export test: sequencer --reapertest <mediafile>
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--reapertest" {
+    runReaperTest(path: CommandLine.arguments[2])
+    exit(0)
+}
+
+// Headless sidecar test against a real bundle: sequencer --sidecartest <file.sq>
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--sidecartest" {
+    runSidecarTest(path: CommandLine.arguments[2])
+    exit(0)
+}
+
+// Headless waveform-peak test: sequencer --peaktest <audiofile>
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--peaktest" {
+    MediaPipeline.shared.runPeakTest(path: CommandLine.arguments[2])
+    exit(0)
+}
+
+// Headless thumbnail-tier test: sequencer --thumbtest <videofile>
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--thumbtest" {
+    MediaPipeline.shared.runThumbTest(path: CommandLine.arguments[2])
+    exit(0)
+}
+
 if CommandLine.arguments.contains("--uitest") {
     _ = NSApplication.shared // AppKit needs an app instance for views/windows
     MainActor.assumeIsolated { runUITest() }
@@ -34,6 +64,26 @@ if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--perftest" {
     MainActor.assumeIsolated { runPerfTest(path: CommandLine.arguments[2]) }
 }
 
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--snap" {
+    _ = NSApplication.shared
+    MainActor.assumeIsolated { runSnap(args: Array(CommandLine.arguments.dropFirst(2))) }
+}
+
+// Zoom-transient check: renders a settled frame at ppsA, then the FIRST frame
+// after switching to ppsB (the cold zoom frame), then the settled ppsB frame —
+// any pixel difference between the last two is a zoom-transient rendering bug.
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--snapzoom" {
+    _ = NSApplication.shared
+    MainActor.assumeIsolated { runSnapZoom(args: Array(CommandLine.arguments.dropFirst(2))) }
+}
+
+// Pinch-stream transient detector: every zoom step draws twice with identical
+// state; any byte difference between the two draws is a rendering bug.
+if CommandLine.arguments.count >= 3, CommandLine.arguments[1] == "--snappinch" {
+    _ = NSApplication.shared
+    MainActor.assumeIsolated { runSnapPinch(args: Array(CommandLine.arguments.dropFirst(2))) }
+}
+
 // pkill/SIGTERM (run.sh does one per rebuild) must also take the ffmpeg
 // children down — the default handler kills only this process, minting the
 // orphan encoders that exhaust VideoToolbox and black out the next launch.