diff --git a/backend/cli.py b/backend/cli.py
index 1524668..6c281f8 100644
--- a/backend/cli.py
+++ b/backend/cli.py
@@ -390,6 +390,65 @@ def cmd_studio(args):
     sys.exit(rc)
 
 
+def cmd_reel(args):
+    """Create and iterate on a highlights reel — detect once, then edit moments fast."""
+    from services.reel import (
+        ReelSession, seed_session, edit_moment, build_reel, list_sessions, delete_session,
+    )
+    from services.transcript_packer import compute_cache_hash, load_cached_transcript_for_video
+
+    def _mmss(s):
+        return f"{int(s // 60)}:{int(s % 60):02d}"
+
+    def _show(session):
+        for i, m in enumerate(session.moments, 1):
+            flag = "" if m.enabled else "  (disabled)"
+            print(f"  [{i}] {_mmss(m.start)}-{_mmss(m.end)} ({m.duration:.0f}s, {m.why}){flag}")
+            if m.text:
+                print("      " + (m.text[:150] + "…" if len(m.text) > 150 else m.text))
+
+    action = getattr(args, "reel_action", None)
+    if action == "new":
+        video = _clean_path(args.video)
+        sid = compute_cache_hash(video)
+        out_dir = args.output or os.path.join(os.getcwd(), f"reel_{sid[:8]}")
+        cached = load_cached_transcript_for_video(video)
+        words = cached.get("words") if cached else None
+        print("  Detecting moments (one-time)...")
+        session = seed_session(
+            sid, video, out_dir, profile=args.profile or "auto",
+            format=args.format or "horizontal", top_n=args.top or 10,
+            min_dur=args.min_dur, max_dur=args.max_dur,
+            words=words, progress_callback=lambda p, m: print(f"    {m}") if m else None,
+        )
+        _show(session)
+        print("  Building reel...")
+        reel = build_reel(session)
+        print(f"  ✓ {reel}")
+        print(f"  session: {sid}")
+        print(f"  edit with: podcli reel edit {sid} <N> <longer|shorter|earlier|later|shift|drop|toggle> [secs]")
+    elif action == "list":
+        for s in list_sessions():
+            print(f"  {s['session_id']}  {s['profile']}/{s['format']}  "
+                  f"{s['enabled_count']}/{s['moment_count']} moments  {os.path.basename(s['source'])}")
+    elif action == "delete":
+        ok = delete_session(args.session)
+        print(f"  {'✓ deleted' if ok else '✗ no such session'} {args.session}")
+    elif action == "show":
+        _show(ReelSession.load(args.session))
+    elif action == "edit":
+        session = edit_moment(ReelSession.load(args.session), args.index, args.op, args.seconds)
+        reel = build_reel(session)
+        print(f"  ✓ rebuilt {reel}")
+        _show(session)
+    elif action == "build":
+        reel = build_reel(ReelSession.load(args.session))
+        print(f"  ✓ {reel}")
+    else:
+        print("  Usage: podcli reel new <video> | list | show <session> | "
+              "edit <session> N <op> [secs] | build <session> | delete <session>")
+
+
 def cmd_process(args):
     """Full auto pipeline: transcribe → suggest → export."""
     from services.clip_generator import generate_clip
@@ -462,7 +521,9 @@ def cmd_process(args):
         else:
             print(f"  Warning: Logo '{args.logo}' not found (checked assets and filesystem)", file=sys.stderr)
             config["logo_path"] = args.logo  # pass through anyway
-    if args.outro:
+    if getattr(args, "no_outro", False):
+        config["outro_path"] = ""
+    elif args.outro:
         from services.asset_store import resolve as resolve_asset_outro
         resolved = resolve_asset_outro(args.outro)
         if resolved:
@@ -471,10 +532,14 @@ def cmd_process(args):
             print(f"  Warning: Outro '{args.outro}' not found (checked assets and filesystem)", file=sys.stderr)
             config["outro_path"] = args.outro
     elif not config.get("outro_path"):
-        from services.asset_store import default_outro
-        auto_outro = default_outro()
-        if auto_outro:
-            config["outro_path"] = auto_outro
+        # Highlight profiles (party/action) are raw moments, not branded shorts, so they
+        # skip the auto-outro; the podcast flow keeps it.
+        from services.profiles import get_profile as _get_profile
+        if _get_profile(config.get("profile")).candidate_source != "saliency":
+            from services.asset_store import default_outro
+            auto_outro = default_outro()
+            if auto_outro:
+                config["outro_path"] = auto_outro
     if args.time_adjust is not None:
         config["time_adjust"] = args.time_adjust
     if args.no_energy:
@@ -548,11 +613,31 @@ def cmd_process(args):
     segments = []
     result = {}
 
+    # Saliency profiles (party/action) select on audio/visual signals, not dialogue,
+    # so transcribing a long video would be wasted work — skip it entirely.
+    from services.profiles import get_profile
+
+    content_profile = get_profile(config.get("profile"))
+    skip_transcript = content_profile.candidate_source == "saliency" and not args.transcript
+
     from services.transcript_packer import (
         load_cached_transcript_for_video,
         save_cached_transcript_for_video,
     )
 
+    if skip_transcript:
+        # Reuse an existing transcript so highlight boundaries snap to whole sentences;
+        # only skip transcription outright when there is none (true no-dialogue footage).
+        cached = load_cached_transcript_for_video(video_path)
+        if cached and not config.get("no_cache", False):
+            words = cached["words"]
+            segments = cached["segments"]
+            result = cached
+            skip_transcript = False
+            print(f"  [1/4] Reusing cached transcript ({len(segments)} segments) for sentence-clean cuts")
+        else:
+            print(f"  [1/4] Skipping transcription ({content_profile.name} profile uses audio/visual signals)")
+
     if args.transcript:
         print("  [1/4] Loading transcript...")
         with open(args.transcript, "r", encoding="utf-8") as f:
@@ -578,7 +663,7 @@ def cmd_process(args):
             words = parsed["words"]
             segments = parsed["segments"]
             print(f"         Parsed: {len(segments)} segments, {len(words)} words")
-    else:
+    elif not skip_transcript:
         # Check cache first
         cached = load_cached_transcript_for_video(video_path)
         if cached and not config.get("no_cache", False):
@@ -654,7 +739,7 @@ def _transcribe_progress(pct, msg):
     else:
         print(f"         No speaker data (center crop fallback)")
 
-    if not segments:
+    if not segments and not skip_transcript:
         print("  Error: No transcript segments found.", file=sys.stderr)
         sys.exit(1)
 
@@ -698,9 +783,6 @@ def _transcribe_progress(pct, msg):
 
     # Saliency profiles (party/action) pick moments from the fused laughter/energy
     # curve rather than the transcript, so they work on footage with no dialogue.
-    from services.profiles import get_profile
-
-    content_profile = get_profile(config.get("profile"))
     if content_profile.candidate_source == "saliency" and not clips:
         from services.saliency import detect_highlights
         from services.formats import get_format
@@ -711,8 +793,10 @@ def _transcribe_progress(pct, msg):
             video_path,
             profile_name=content_profile.name,
             top_n=top_n,
-            min_dur=min(8.0, float(spec.dur_min)),
-            max_dur=float(spec.dur_max),
+            min_dur=15.0,
+            max_dur=min(60.0, float(spec.dur_max)),
+            segments=segments or None,
+            words=words or None,
             progress_callback=lambda pct, msg: print(f"         {msg}") if msg else None,
         )
         if clips:
@@ -725,7 +809,9 @@ def _transcribe_progress(pct, msg):
     from services.claude_suggest import suggest_initial_with_claude, _engine_label, _find_ai_cli
 
     ai_path, ai_engine = _find_ai_cli()
-    if not clips and ai_path and config.get("ai_select", True):
+    if clips:
+        pass  # already selected (resumed cache or saliency profile)
+    elif ai_path and config.get("ai_select", True):
         ai_label = _engine_label(ai_engine)
         print(f"  [3/4] Selecting moments with {ai_label} (PodStack)...")
         clips = suggest_initial_with_claude(
@@ -3368,6 +3454,7 @@ def main():
     proc.add_argument("--profile", choices=["podcast", "party", "action"], help="Detection profile: podcast (transcript-first, default), party/action (laughter/energy highlights)")
     proc.add_argument("--logo", help="Logo image (asset name or path)")
     proc.add_argument("--outro", help="Outro video (asset name or path)")
+    proc.add_argument("--no-outro", action="store_true", help="Do not append an outro (default for highlight profiles)")
     proc.add_argument("--time-adjust", type=float, help="Timestamp offset in seconds")
     proc.add_argument("--no-energy", action="store_true", help="Skip audio energy analysis")
     proc.add_argument("--no-speakers", action="store_true", help="Skip speaker detection (faster, uses face detection only)")
@@ -3378,6 +3465,33 @@ def main():
     proc.add_argument("--review-each", action="store_true", help="Review each rendered clip interactively")
     proc.add_argument("--post-review", action="store_true", help="Open the post-render review loop after export")
 
+    # ── reel (highlights, detect once then iterate fast) ──
+    reel_p = sub.add_parser("reel", help="Create and iterate on a highlights reel")
+    reel_sub = reel_p.add_subparsers(dest="reel_action")
+    rn = reel_sub.add_parser("new", help="Detect moments and build a reel")
+    rn.add_argument("video", help="Path to the source video")
+    rn.add_argument("--profile", choices=["auto", "party", "action"], default="auto")
+    rn.add_argument("--format", choices=["vertical", "horizontal", "square"], default="horizontal",
+                    help="Reel aspect ratio (default horizontal 1920x1080)")
+    rn.add_argument("-n", "--top", type=int, help="Number of moments (default 10)")
+    rn.add_argument("--min-dur", type=float, default=15.0, dest="min_dur",
+                    help="Shortest moment in seconds (default 15)")
+    rn.add_argument("--max-dur", type=float, default=60.0, dest="max_dur",
+                    help="Longest moment in seconds (default 60)")
+    rn.add_argument("-o", "--output", help="Output directory")
+    reel_sub.add_parser("list", help="List saved reel sessions")
+    rdel = reel_sub.add_parser("delete", help="Delete a reel session")
+    rdel.add_argument("session")
+    rsh = reel_sub.add_parser("show", help="List the moments in a reel session")
+    rsh.add_argument("session", help="Session id (printed by 'reel new')")
+    red = reel_sub.add_parser("edit", help="Adjust one moment and rebuild")
+    red.add_argument("session")
+    red.add_argument("index", type=int, help="1-based moment number")
+    red.add_argument("op", choices=["longer", "shorter", "earlier", "later", "shift", "drop", "toggle"])
+    red.add_argument("seconds", type=float, nargs="?", default=0.0)
+    rbd = reel_sub.add_parser("build", help="Rebuild the reel (re-cuts only changed moments)")
+    rbd.add_argument("session")
+
     # ── studio ──
     studio = sub.add_parser("studio", help="Cut a fragment + add Remotion intro/outro (follow-us) bookends")
     studio.add_argument("video", nargs="?", default=None, help="Path to the source video (omit only with --save-brand)")
@@ -3633,6 +3747,8 @@ def main():
         cmd_process(args)
     elif args.command == "studio":
         cmd_studio(args)
+    elif args.command == "reel":
+        cmd_reel(args)
     elif args.command == "thumbnails":
         cmd_thumbnails(args)
     elif args.command == "thumbnail-config":
diff --git a/backend/main.py b/backend/main.py
index 03a4d93..5501b49 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -339,6 +339,80 @@ def handle_detect_highlights(task_id: str, params: dict):
     emit_result(task_id, "success", data={"clips": clips, "count": len(clips)})
 
 
+def handle_manage_reel(task_id: str, params: dict):
+    """Create and iterate on a highlights reel — the MCP surface over the reel service.
+
+    Actions: new (detect + build), list, show, edit (adjust one moment + rebuild),
+    build, delete.
+    """
+    from dataclasses import asdict
+    from services.reel import (
+        ReelSession, seed_session, edit_moment, build_reel, list_sessions, delete_session,
+    )
+
+    action = params.get("action", "show")
+
+    def payload(session, reel=None):
+        moments = []
+        for i, m in enumerate(session.moments, 1):
+            d = asdict(m)
+            d["clip_path"] = os.path.join(session.out_dir, "clips", f"clip_{i:02d}.mp4")
+            d["clip_exists"] = os.path.exists(d["clip_path"])
+            moments.append(d)
+        reel_file = reel or os.path.join(session.out_dir, "highlights_reel.mp4")
+        return {
+            "session_id": session.session_id,
+            "source": session.source,
+            "format": session.format,
+            "out_dir": session.out_dir,
+            "reel_path": reel_file if os.path.exists(reel_file) else None,
+            "moments": moments,
+        }
+
+    try:
+        if action == "new":
+            from services.transcript_packer import compute_cache_hash, load_cached_transcript_for_video
+            video = params["video_path"]
+            sid = compute_cache_hash(video)
+            out_dir = params.get("out_dir") or os.path.join(os.getcwd(), f"reel_{sid[:8]}")
+            cached = load_cached_transcript_for_video(video)
+            words = cached.get("words") if cached else None
+            session = seed_session(
+                sid, video, out_dir, profile=params.get("profile", "auto"),
+                format=params.get("format", "horizontal"),
+                top_n=int(params.get("top_n", 10)),
+                min_dur=float(params.get("min_dur", 15.0)),
+                max_dur=float(params.get("max_dur", 60.0)),
+                words=words,
+                progress_callback=lambda p, m: emit_progress(task_id, "detecting", p, m),
+            )
+            reel = build_reel(session, progress_callback=lambda p, m: emit_progress(task_id, "building", p, m))
+            emit_result(task_id, "success", data=payload(session, reel))
+        elif action == "list":
+            emit_result(task_id, "success", data={"sessions": list_sessions()})
+        elif action == "delete":
+            ok = delete_session(params["session_id"])
+            emit_result(task_id, "success", data={"deleted": ok, "session_id": params["session_id"]})
+        elif action == "show":
+            emit_result(task_id, "success", data=payload(ReelSession.load(params["session_id"])))
+        elif action == "edit":
+            session = edit_moment(
+                ReelSession.load(params["session_id"]),
+                int(params["index"]), params["op"], float(params.get("seconds", 0.0)),
+                start=params.get("start"), end=params.get("end"),
+            )
+            reel = build_reel(session, progress_callback=lambda p, m: emit_progress(task_id, "building", p, m))
+            emit_result(task_id, "success", data=payload(session, reel))
+        elif action == "build":
+            session = ReelSession.load(params["session_id"])
+            reel = build_reel(session, progress_callback=lambda p, m: emit_progress(task_id, "building", p, m))
+            emit_result(task_id, "success", data=payload(session, reel))
+        else:
+            emit_result(task_id, "error", error=f"unknown reel action {action!r}")
+    except (KeyError, IndexError, ValueError, FileNotFoundError) as e:
+        emit_result(task_id, "error", error=str(e))
+
+
 def handle_detect_encoder(task_id: str, params: dict):
     """Detect available hardware encoders."""
     from services.encoder import get_encoder_info
@@ -633,6 +707,7 @@ def handle_run_integration_tool(task_id: str, params: dict):
     "batch_clips": handle_batch_clips,
     "analyze_energy": handle_analyze_energy,
     "detect_highlights": handle_detect_highlights,
+    "manage_reel": handle_manage_reel,
     "pack_transcript": handle_pack_transcript,
     "detect_encoder": handle_detect_encoder,
     "presets": handle_presets,
diff --git a/backend/services/profiles.py b/backend/services/profiles.py
index c5450da..822bd35 100644
--- a/backend/services/profiles.py
+++ b/backend/services/profiles.py
@@ -35,6 +35,17 @@ def _weights(**kw) -> dict[str, float]:
 
 
 PROFILES = {
+    "auto": ContentProfile(
+        name="auto",
+        candidate_source="saliency",
+        channel_weights=_weights(
+            audio_event=0.3, energy=0.25, motion=0.2, prosody=0.15, face_reaction=0.1
+        ),
+        reaction_lookback_sec=7.0,
+        reaction_payoff_sec=2.0,
+        peak_min_gap_sec=8.0,
+        peak_top_percentile=0.15,
+    ),
     "podcast": ContentProfile(
         name="podcast",
         candidate_source="llm",
diff --git a/backend/services/reel.py b/backend/services/reel.py
new file mode 100644
index 0000000..9914f3f
--- /dev/null
+++ b/backend/services/reel.py
@@ -0,0 +1,247 @@
+"""Editable highlight-reel sessions — the shared core behind the CLI, MCP, and UI.
+
+Detection (the slow signal analysis) runs once into a persisted session of moments.
+Every later edit — longer, shorter, shift, drop, reorder — mutates that session and
+re-cuts only the changed moment straight from the source (~seconds), then rebuilds the
+reel. No re-detection, no heavy render. All three surfaces operate on the same session
+so an edit made in one shows up in the others.
+"""
+
+import json
+import os
+import subprocess
+from dataclasses import dataclass, field, asdict
+from typing import Optional, Callable
+
+from utils.proc import run as proc_run
+from config.paths import paths
+from services.formats import get_format
+
+
+def _sessions_dir() -> str:
+    # paths["packed"] is .podcli/packed; its parent is the .podcli root.
+    d = os.path.join(os.path.dirname(paths["packed"]), "reels")
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def session_path(session_id: str) -> str:
+    return os.path.join(_sessions_dir(), f"{session_id}.json")
+
+
+@dataclass
+class Moment:
+    start: float
+    end: float
+    why: str = "energy_peak"
+    text: str = ""
+    enabled: bool = True
+    dirty: bool = True  # needs a re-cut before the next build
+
+    @property
+    def duration(self) -> float:
+        return round(self.end - self.start, 1)
+
+
+@dataclass
+class ReelSession:
+    session_id: str
+    source: str
+    profile: str
+    out_dir: str
+    format: str = "horizontal"
+    moments: list[Moment] = field(default_factory=list)
+
+    def save(self) -> str:
+        path = session_path(self.session_id)
+        data = asdict(self)
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)
+        return path
+
+    @classmethod
+    def load(cls, session_id: str) -> "ReelSession":
+        with open(session_path(session_id)) as f:
+            data = json.load(f)
+        data["moments"] = [Moment(**m) for m in data.get("moments", [])]
+        return cls(**data)
+
+
+def _clip_text(words: list[dict], a: float, b: float) -> str:
+    return " ".join(
+        str(w.get("word", "")).strip()
+        for w in words
+        if w.get("start", 0) >= a - 0.05 and w.get("end", 0) <= b + 0.05
+    )
+
+
+def seed_session(
+    session_id: str,
+    source: str,
+    out_dir: str,
+    profile: str = "auto",
+    format: str = "horizontal",
+    top_n: int = 10,
+    min_dur: float = 15.0,
+    max_dur: float = 60.0,
+    words: Optional[list[dict]] = None,
+    progress_callback: Optional[Callable] = None,
+) -> ReelSession:
+    """Run detection once and persist the moments as an editable session."""
+    from services.saliency import detect_highlights
+
+    clips = detect_highlights(
+        source, profile_name=profile, top_n=top_n, min_dur=min_dur, max_dur=max_dur,
+        words=words, progress_callback=progress_callback,
+    )
+    moments = [
+        Moment(
+            start=round(c["start_second"], 1),
+            end=round(c["end_second"], 1),
+            why=c.get("reasons", ["energy_peak"])[0],
+            text=_clip_text(words, c["start_second"], c["end_second"]) if words else "",
+        )
+        for c in clips
+    ]
+    session = ReelSession(
+        session_id, source, profile, out_dir, format=get_format(format).name, moments=moments
+    )
+    session.save()
+    return session
+
+
+_EDITS = {
+    "longer":  lambda m, s: setattr(m, "end", round(m.end + s, 1)),
+    "shorter": lambda m, s: setattr(m, "end", round(max(m.start + 1, m.end - s), 1)),
+    "earlier": lambda m, s: setattr(m, "start", round(max(0.0, m.start - s), 1)),
+    "later":   lambda m, s: setattr(m, "start", round(min(m.end - 1, m.start + s), 1)),
+    "shift":   lambda m, s: (setattr(m, "start", round(max(0.0, m.start + s), 1)),
+                             setattr(m, "end", round(m.end + s, 1))),
+}
+
+
+def edit_moment(
+    session: ReelSession,
+    index: int,
+    op: str,
+    seconds: float = 0.0,
+    start: Optional[float] = None,
+    end: Optional[float] = None,
+) -> ReelSession:
+    """Apply an edit to one moment (1-based index) and mark it for re-cut."""
+    if not (1 <= index <= len(session.moments)):
+        raise IndexError(f"no moment {index} (have {len(session.moments)})")
+    m = session.moments[index - 1]
+    if op == "drop":
+        session.moments.pop(index - 1)
+        # Clip files are keyed by position, so everything after the hole now maps
+        # to a stale neighbour's cut. Force those to re-cut on the next build.
+        for shifted in session.moments[index - 1:]:
+            shifted.dirty = True
+    elif op == "toggle":
+        m.enabled = not m.enabled
+    elif op == "set":
+        if start is not None:
+            m.start = round(max(0.0, float(start)), 1)
+        if end is not None:
+            m.end = round(float(end), 1)
+        if m.end <= m.start:
+            m.end = round(m.start + 1.0, 1)
+        m.dirty = True
+    elif op in _EDITS:
+        _EDITS[op](m, seconds)
+        m.dirty = True
+    else:
+        raise ValueError(f"unknown op {op!r}")
+    session.save()
+    return session
+
+
+def _scale_filter(format: str) -> str:
+    spec = get_format(format)
+    w, h = spec.width, spec.height
+    if spec.reframe:
+        # Vertical/square from a wider source: cover the frame, then centre-crop.
+        return f"scale={w}:{h}:force_original_aspect_ratio=increase,crop={w}:{h}"
+    return (f"scale={w}:{h}:force_original_aspect_ratio=decrease,"
+            f"pad={w}:{h}:(ow-iw)/2:(oh-ih)/2")
+
+
+def _cut(source: str, out_dir: str, idx: int, m: Moment, format: str) -> str:
+    clips_dir = os.path.join(out_dir, "clips")
+    os.makedirs(clips_dir, exist_ok=True)
+    out = os.path.join(clips_dir, f"clip_{idx:02d}.mp4")
+    proc_run([
+        "ffmpeg", "-y", "-ss", str(m.start), "-i", source, "-t", str(m.duration),
+        "-vf", _scale_filter(format),
+        "-c:v", "libx264", "-preset", "veryfast", "-crf", "20",
+        "-c:a", "aac", "-b:a", "192k", out, "-loglevel", "error",
+    ], timeout=120, check=True)
+    return out
+
+
+def build_reel(session: ReelSession, progress_callback: Optional[Callable] = None) -> str:
+    """Re-cut only dirty moments, then concatenate all enabled moments into the reel."""
+    os.makedirs(session.out_dir, exist_ok=True)
+    files = []
+    active = [(i, m) for i, m in enumerate(session.moments, 1) if m.enabled]
+    for n, (i, m) in enumerate(active, 1):
+        clip = os.path.join(session.out_dir, "clips", f"clip_{i:02d}.mp4")
+        if m.dirty or not os.path.exists(clip):
+            if progress_callback:
+                progress_callback(int(n / len(active) * 90), f"cutting moment {i}")
+            clip = _cut(session.source, session.out_dir, i, m, session.format)
+            m.dirty = False
+        files.append(clip)
+    session.save()
+
+    reel = os.path.join(session.out_dir, "highlights_reel.mp4")
+    lst = os.path.join(session.out_dir, "_concat.txt")
+    with open(lst, "w") as f:
+        f.write("".join(f"file '{os.path.abspath(x)}'\n" for x in files))
+    r = proc_run(["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", lst,
+                  "-c", "copy", reel, "-loglevel", "error"], timeout=300, check=False)
+    if r.returncode != 0:
+        proc_run(["ffmpeg", "-y", "-f", "concat", "-safe", "0", "-i", lst,
+                  "-c:v", "libx264", "-c:a", "aac", reel, "-loglevel", "error"],
+                 timeout=600, check=True)
+    if progress_callback:
+        progress_callback(100, f"built reel with {len(files)} moments")
+    return reel
+
+
+def list_sessions() -> list[dict]:
+    """Summaries of every persisted reel session, newest first."""
+    out = []
+    d = _sessions_dir()
+    for name in os.listdir(d):
+        if not name.endswith(".json"):
+            continue
+        path = os.path.join(d, name)
+        try:
+            with open(path) as f:
+                data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            continue
+        moments = data.get("moments", [])
+        reel = os.path.join(data.get("out_dir", ""), "highlights_reel.mp4")
+        out.append({
+            "session_id": data.get("session_id", name[:-5]),
+            "source": data.get("source", ""),
+            "profile": data.get("profile", ""),
+            "format": data.get("format", "horizontal"),
+            "moment_count": len(moments),
+            "enabled_count": sum(1 for m in moments if m.get("enabled", True)),
+            "reel_path": reel if os.path.exists(reel) else None,
+            "mtime": os.path.getmtime(path),
+        })
+    out.sort(key=lambda s: s["mtime"], reverse=True)
+    return out
+
+
+def delete_session(session_id: str) -> bool:
+    path = session_path(session_id)
+    if not os.path.exists(path):
+        return False
+    os.remove(path)
+    return True
diff --git a/backend/services/saliency.py b/backend/services/saliency.py
index bcedb8c..a1dc36f 100644
--- a/backend/services/saliency.py
+++ b/backend/services/saliency.py
@@ -117,6 +117,71 @@ def _snap_to_quiet(target_sec: float, energy_curve: np.ndarray, window_sec: floa
     return (lo + int(np.argmin(local))) / GRID_HZ
 
 
+def sentences_from_words(words: list[dict]) -> list[dict]:
+    """Group word-level timestamps into sentences on terminal punctuation.
+
+    Whisper *segments* often straddle a sentence boundary ("...was. But then..."), so
+    snapping to them still starts a clip mid-thought. Splitting on .?! gives real
+    sentence edges to snap to.
+    """
+    sents: list[dict] = []
+    start = None
+    end = None
+    for w in words:
+        text = str(w.get("word", "")).strip()
+        if not text:
+            continue
+        if start is None:
+            start = w.get("start", 0.0)
+        end = w.get("end", start)
+        if text.endswith((".", "?", "!")):
+            sents.append({"start": start, "end": end})
+            start = None
+    if start is not None:
+        sents.append({"start": start, "end": end})
+    return sents
+
+
+def _seg_index_at(t: float, segments: list[dict]) -> int:
+    """Index of the segment covering t, else the nearest segment start."""
+    for i, s in enumerate(segments):
+        if s.get("start", 0) <= t <= s.get("end", 0):
+            return i
+    return min(range(len(segments)), key=lambda i: abs(segments[i].get("start", 0) - t))
+
+
+def _sentence_window(
+    peak_sec: float,
+    back_sec: float,
+    fwd_sec: float,
+    segments: list[dict],
+    min_dur: float,
+    max_dur: float,
+) -> tuple[float, float]:
+    """Build a clip out of whole segments (sentences) so it never cuts mid-thought.
+
+    Starts at a sentence boundary, extends back ~back_sec and forward ~fwd_sec (and
+    enough to clear min_dur), always snapping to segment edges and never exceeding
+    max_dur.
+    """
+    idx = _seg_index_at(peak_sec, segments)
+    start = segments[idx].get("start", peak_sec)
+    end = segments[idx].get("end", peak_sec)
+    i = idx
+    while i > 0 and (peak_sec - segments[i - 1]["start"]) <= back_sec and (end - segments[i - 1]["start"]) <= max_dur:
+        i -= 1
+        start = segments[i]["start"]
+    j = idx
+    while (
+        j < len(segments) - 1
+        and (segments[j + 1]["end"] - start) <= max_dur
+        and ((end - start) < min_dur or (segments[j]["end"] - peak_sec) < fwd_sec)
+    ):
+        j += 1
+        end = segments[j]["end"]
+    return start, end
+
+
 def _window_for_peak(
     peak_sec: float,
     reaction_level: float,
@@ -125,27 +190,32 @@ def _window_for_peak(
     energy_curve: np.ndarray,
     min_dur: float,
     max_dur: float,
+    segments: Optional[list[dict]] = None,
+    reaction_threshold: float = 0.06,
 ) -> tuple[float, float, bool]:
-    """Clip window for a peak. A reaction peak expands backwards from the reaction onset."""
-    is_reaction = reaction_level >= 0.15
-    if is_reaction:
-        # The funny thing happens BEFORE the laugh, so keep the run-up: expand backwards
-        # from the reaction, snap only the end to a lull, and grow the start (not the
-        # end) if we're under the minimum so the payoff stays put.
-        start = max(0.0, peak_sec - profile.reaction_lookback_sec)
-        end = _snap_to_quiet(min(duration, peak_sec + profile.reaction_payoff_sec), energy_curve)
-        if end - start < min_dur:
-            start = max(0.0, end - min_dur)
-        elif end - start > max_dur:
-            start = end - max_dur
+    """Clip window for a peak. A reaction peak expands backwards from the reaction onset.
+
+    With a transcript, boundaries snap to whole sentences so each clip is a complete
+    thought; without one (party footage) they snap to audio lulls instead.
+    """
+    is_reaction = reaction_level >= reaction_threshold
+    back = profile.reaction_lookback_sec if is_reaction else min_dur / 2.0
+    fwd = profile.reaction_payoff_sec if is_reaction else min_dur / 2.0
+
+    if segments:
+        start, end = _sentence_window(peak_sec, back, fwd, segments, min_dur, max_dur)
     else:
-        half = min_dur / 2.0
-        start = _snap_to_quiet(max(0.0, peak_sec - half), energy_curve)
-        end = _snap_to_quiet(min(duration, peak_sec + half), energy_curve)
+        start = _snap_to_quiet(max(0.0, peak_sec - back), energy_curve)
+        end = _snap_to_quiet(min(duration, peak_sec + fwd), energy_curve)
         if end - start < min_dur:
-            end = min(duration, start + min_dur)
+            if is_reaction:
+                start = max(0.0, end - min_dur)
+            else:
+                end = min(duration, start + min_dur)
         elif end - start > max_dur:
+            start = end - max_dur if is_reaction else start
             end = start + max_dur
+
     return round(max(0.0, start), 1), round(min(duration, end), 1), is_reaction
 
 
@@ -156,15 +226,24 @@ def detect_highlights(
     min_dur: float = 8.0,
     max_dur: float = 60.0,
     height_z: float = 1.0,
+    segments: Optional[list[dict]] = None,
+    words: Optional[list[dict]] = None,
+    reaction_threshold: float = 0.06,
     progress_callback: Optional[Callable] = None,
 ) -> list[dict]:
     """
-    Generate highlight clips from a video's fused signal curve (no transcript needed).
+    Generate highlight clips from a video's fused signal curve.
 
+    If a transcript is provided, clip boundaries snap to whole sentences so each clip
+    is a complete thought; `words` (with punctuation) gives true sentence edges and is
+    preferred over `segments`. Without any transcript, boundaries snap to audio lulls.
+    `reaction_threshold` is the laughter/cheer level that counts as a reaction — low
+    (~0.06) for conversational chuckles, higher for loud belly-laughs/crowds.
     Returns clip dicts compatible with the render pipeline:
     {title, start_second, end_second, duration, score, reasons, preview}.
     """
     profile = get_profile(profile_name)
+    snap_units = sentences_from_words(words) if words else segments
 
     if progress_callback:
         progress_callback(10, "Analyzing audio energy...")
@@ -201,7 +280,7 @@ def detect_highlights(
     # worth a clip regardless of loudness, so they aren't made to out-compete energy in
     # the blended curve. Energy peaks then fill the rest, minus any that collide with a
     # reaction. Reaction score is offset above energy so reactions rank first.
-    reaction_peaks = pick_peaks(reaction_curve, 0.15, min_gap_bins)
+    reaction_peaks = pick_peaks(reaction_curve, reaction_threshold, min_gap_bins)
     energy_peaks = pick_peaks(fused, height_z, min_gap_bins)
 
     candidates = [(i, float(reaction_curve[i]), True) for i in reaction_peaks]
@@ -222,7 +301,8 @@ def rank_key(c):
         peak_sec = i / GRID_HZ
         reaction_level = float(reaction_curve[i]) if want_reaction else 0.0
         start, end, is_reaction = _window_for_peak(
-            peak_sec, reaction_level, profile, duration, energy_curve, min_dur, max_dur
+            peak_sec, reaction_level, profile, duration, energy_curve, min_dur, max_dur,
+            snap_units, reaction_threshold,
         )
         if end - start < min_dur * 0.75:
             continue
diff --git a/src/models/index.ts b/src/models/index.ts
index d275502..cc9fa24 100644
--- a/src/models/index.ts
+++ b/src/models/index.ts
@@ -2,7 +2,7 @@
 
 export interface TaskRequest {
   task_id: string;
-  task_type: "transcribe" | "parse_transcript" | "create_clip" | "batch_clips" | "analyze_energy" | "pack_transcript" | "detect_encoder" | "presets" | "ping" | "suggest_clips" | "find_moment" | "generate_content" | "generate_custom" | "corrections" | "manage_integrations" | "run_integration_tool" | "manage_config" | "manage_env" | "ai_cli_status";
+  task_type: "transcribe" | "parse_transcript" | "create_clip" | "batch_clips" | "analyze_energy" | "detect_highlights" | "manage_reel" | "pack_transcript" | "detect_encoder" | "presets" | "ping" | "suggest_clips" | "find_moment" | "generate_content" | "generate_custom" | "corrections" | "manage_integrations" | "run_integration_tool" | "manage_config" | "manage_env" | "ai_cli_status";
   params: Record<string, unknown>;
 }
 
diff --git a/src/server.ts b/src/server.ts
index 2f8319f..9d91fc0 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -2055,6 +2055,96 @@ export function createServer(): McpServer {
     },
   );
 
+  // =============================================
+  // Tool: manage_reel
+  // =============================================
+  server.tool(
+    "manage_reel",
+    "Create and iterate on a highlights reel. Detection runs once with action 'new'; after that, edit individual moments fast (longer/shorter/earlier/later/shift/drop/toggle) and rebuild without re-detecting. Actions: 'new' (video_path, profile, format, top_n, min_dur, max_dur), 'list', 'show' (session_id), 'edit' (session_id, index, op, seconds), 'build' (session_id), 'delete' (session_id).",
+    {
+      action: z
+        .enum(["new", "list", "show", "edit", "build", "delete"])
+        .describe("What to do with the reel"),
+      video_path: z
+        .string()
+        .optional()
+        .describe("For 'new': path to the source video"),
+      session_id: z
+        .string()
+        .optional()
+        .describe("For show/edit/build/delete: the reel session id returned by 'new'"),
+      profile: z
+        .enum(["auto", "party", "action"])
+        .optional()
+        .describe("For 'new': detection profile (default auto)"),
+      format: z
+        .enum(["vertical", "horizontal", "square"])
+        .optional()
+        .describe("For 'new': reel aspect ratio (default horizontal)"),
+      top_n: z.number().optional().describe("For 'new': number of moments"),
+      min_dur: z.number().optional().describe("For 'new': shortest moment in seconds (default 15)"),
+      max_dur: z.number().optional().describe("For 'new': longest moment in seconds (default 60)"),
+      index: z
+        .number()
+        .optional()
+        .describe("For 'edit': 1-based moment number to adjust"),
+      op: z
+        .enum(["longer", "shorter", "earlier", "later", "shift", "set", "drop", "toggle"])
+        .optional()
+        .describe("For 'edit': how to change the moment"),
+      seconds: z
+        .number()
+        .optional()
+        .describe("For 'edit': seconds for longer/shorter/earlier/later/shift"),
+      start: z
+        .number()
+        .optional()
+        .describe("For 'edit' with op 'set': absolute start time in seconds"),
+      end: z
+        .number()
+        .optional()
+        .describe("For 'edit' with op 'set': absolute end time in seconds"),
+    },
+    async (params) => {
+      try {
+        const res = await fetch("http://localhost:3847/api/reel", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(params),
+        });
+        if (!res.ok) throw new Error(`HTTP ${res.status}`);
+        const data = (await res.json()) as ApiError & Record<string, unknown>;
+        if (data.error) {
+          return {
+            content: [{ type: "text" as const, text: `Error: ${data.error}` }],
+            isError: true,
+          };
+        }
+        return {
+          content: [
+            { type: "text" as const, text: JSON.stringify(data, null, 2) },
+          ],
+        };
+      } catch (err: unknown) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("ECONNREFUSED") || msg.includes("fetch failed")) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "Web UI is not running. Start with: npm run ui",
+              },
+            ],
+          };
+        }
+        return {
+          content: [{ type: "text" as const, text: `Error: ${msg}` }],
+          isError: true,
+        };
+      }
+    },
+  );
+
   // =============================================
   // Tool: set_video
   // =============================================
diff --git a/src/ui/client/HighlightsPage.tsx b/src/ui/client/HighlightsPage.tsx
new file mode 100644
index 0000000..206da83
--- /dev/null
+++ b/src/ui/client/HighlightsPage.tsx
@@ -0,0 +1,500 @@
+import React, { useEffect, useRef, useState } from "react";
+import { api, basename } from "./lib";
+import { BackIcon, TrashIcon, PlayIcon, PauseIcon, DownloadIcon } from "./icons";
+
+interface Moment {
+  start: number;
+  end: number;
+  why: string;
+  text: string;
+  enabled: boolean;
+  dirty: boolean;
+  clip_path?: string;
+  clip_exists?: boolean;
+}
+
+interface HighlightsResp {
+  session_id: string;
+  source: string;
+  format: string;
+  out_dir: string;
+  reel_path: string | null;
+  moments: Moment[];
+}
+
+interface SessionSummary {
+  session_id: string;
+  source: string;
+  profile: string;
+  format: string;
+  moment_count: number;
+  enabled_count: number;
+  reel_path: string | null;
+}
+
+type Format = "vertical" | "horizontal" | "square";
+
+const download = (p: string) => `/api/reel-download?path=${encodeURIComponent(p)}`;
+
+const FORMAT_LABEL: Record<Format, string> = {
+  horizontal: "16:9",
+  vertical: "9:16",
+  square: "1:1",
+};
+
+const mmss = (s: number) => {
+  const t = Math.max(0, s);
+  return `${Math.floor(t / 60)}:${String(Math.floor(t % 60)).padStart(2, "0")}`;
+};
+
+function Field({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div>
+      <label className="field-label">{label}</label>
+      {children}
+    </div>
+  );
+}
+
+function MomentTrim({
+  src,
+  moment,
+  onCommit,
+  saving,
+}: {
+  src: string;
+  moment: Moment;
+  onCommit: (start: number, end: number) => void;
+  saving: boolean;
+}) {
+  const video = useRef<HTMLVideoElement>(null);
+  const trackRef = useRef<HTMLDivElement>(null);
+  const [dur, setDur] = useState(0);
+  const [cur, setCur] = useState(moment.start);
+  const [playing, setPlaying] = useState(false);
+  const [draft, setDraft] = useState<{ start: number; end: number } | null>(null);
+  const drag = useRef<null | "in" | "out">(null);
+
+  const start = draft?.start ?? moment.start;
+  const end = draft?.end ?? moment.end;
+
+  const pad = Math.max(8, (moment.end - moment.start) * 0.6);
+  const winA = Math.max(0, moment.start - pad);
+  const winB = Math.min(dur || moment.end + pad, moment.end + pad);
+  const span = Math.max(0.1, winB - winA);
+  const pct = (t: number) => `${((t - winA) / span) * 100}%`;
+
+  useEffect(() => {
+    const v = video.current;
+    if (v) v.currentTime = moment.start;
+    setCur(moment.start);
+  }, [moment.start, moment.end, src]);
+
+  const timeAt = (clientX: number) => {
+    const el = trackRef.current;
+    if (!el) return winA;
+    const r = el.getBoundingClientRect();
+    return winA + Math.max(0, Math.min(1, (clientX - r.left) / r.width)) * span;
+  };
+
+  const onMove = (e: React.PointerEvent) => {
+    if (!drag.current) return;
+    const t = timeAt(e.clientX);
+    setDraft((d) => {
+      const base = d ?? { start: moment.start, end: moment.end };
+      if (drag.current === "in") return { start: Math.min(t, base.end - 0.5), end: base.end };
+      return { start: base.start, end: Math.max(t, base.start + 0.5) };
+    });
+    if (video.current) {
+      video.current.currentTime = t;
+      setCur(t);
+    }
+  };
+
+  const endDrag = (e: React.PointerEvent) => {
+    if (!drag.current) return;
+    e.currentTarget.releasePointerCapture(e.pointerId);
+    drag.current = null;
+    if (draft) onCommit(round1(draft.start), round1(draft.end));
+  };
+
+  const toggle = () => {
+    const v = video.current;
+    if (!v) return;
+    if (v.paused) {
+      if (v.currentTime < start || v.currentTime >= end) v.currentTime = start;
+      v.play();
+    } else v.pause();
+  };
+
+  const onTime = (e: React.SyntheticEvent<HTMLVideoElement>) => {
+    const t = e.currentTarget.currentTime;
+    if (playing && t >= end) {
+      e.currentTarget.currentTime = start;
+      setCur(start);
+    } else setCur(t);
+  };
+
+  return (
+    <div>
+      <div className="clip-player" style={{ marginBottom: 10 }}>
+        <video
+          ref={video}
+          src={src}
+          playsInline
+          preload="metadata"
+          onClick={toggle}
+          onPlay={() => setPlaying(true)}
+          onPause={() => setPlaying(false)}
+          onTimeUpdate={onTime}
+          onLoadedMetadata={(e) => setDur(e.currentTarget.duration)}
+          style={{ maxHeight: 360, width: "100%", objectFit: "contain", background: "#000" }}
+        />
+      </div>
+
+      <div style={{ display: "flex", alignItems: "center", gap: 12 }}>
+        <button className="clip-player-btn" onClick={toggle} aria-label={playing ? "Pause" : "Play"}
+          style={{ flexShrink: 0 }}>
+          {playing ? <PauseIcon /> : <PlayIcon />}
+        </button>
+        <div
+          ref={trackRef}
+          className="rf-track"
+          style={{ flex: 1, marginTop: 0 }}
+          onPointerMove={onMove}
+          onPointerUp={endDrag}
+        >
+          <div className="rf-region" style={{ left: pct(start), width: `calc(${pct(end)} - ${pct(start)})` }} />
+          <div className="rf-playhead" style={{ left: pct(cur) }} />
+          <div
+            className="rf-handle"
+            style={{ left: pct(start), background: "var(--accent)" }}
+            onPointerDown={(e) => { e.currentTarget.setPointerCapture(e.pointerId); drag.current = "in"; }}
+          />
+          <div
+            className="rf-handle"
+            style={{ left: pct(end), background: "var(--accent)" }}
+            onPointerDown={(e) => { e.currentTarget.setPointerCapture(e.pointerId); drag.current = "out"; }}
+          />
+        </div>
+        <span className="clip-player-time" style={{ minWidth: 118, textAlign: "right", fontVariantNumeric: "tabular-nums" }}>
+          {saving ? "saving…" : `${mmss(start)}–${mmss(end)} · ${Math.round(end - start)}s`}
+        </span>
+      </div>
+    </div>
+  );
+}
+
+const round1 = (n: number) => Math.round(n * 10) / 10;
+
+export default function HighlightsPage() {
+  const [sessions, setSessions] = useState<SessionSummary[]>([]);
+  const [videoPath, setVideoPath] = useState("");
+  const [browsing, setBrowsing] = useState(false);
+  const [dragOver, setDragOver] = useState(false);
+  const [format, setFormat] = useState<Format>("horizontal");
+  const [topN, setTopN] = useState(10);
+  const [minDur, setMinDur] = useState(15);
+  const [maxDur, setMaxDur] = useState(60);
+  const [session, setSession] = useState<HighlightsResp | null>(null);
+  const [selected, setSelected] = useState(0);
+  const [busy, setBusy] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [msg, setMsg] = useState<string | null>(null);
+
+  async function refreshList() {
+    try {
+      const r = await api<{ sessions: SessionSummary[] }>("/reel", {
+        method: "POST",
+        body: JSON.stringify({ action: "list" }),
+      });
+      setSessions(r.sessions || []);
+    } catch {
+      /* list is best-effort */
+    }
+  }
+
+  useEffect(() => {
+    refreshList();
+  }, []);
+
+  async function call(body: Record<string, unknown>, label: string) {
+    setBusy(true);
+    setMsg(label);
+    try {
+      const r = await api<HighlightsResp>("/reel", { method: "POST", body: JSON.stringify(body) });
+      setSession(r);
+      setSelected(0);
+      setMsg(null);
+      refreshList();
+    } catch (e: unknown) {
+      setMsg("Error: " + (e instanceof Error ? e.message : String(e)));
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function browse() {
+    setBrowsing(true);
+    try {
+      const d = await api<{ file_path?: string }>("/browse-file");
+      if (d.file_path) setVideoPath(d.file_path);
+    } catch {
+      /* dialog cancelled */
+    } finally {
+      setBrowsing(false);
+    }
+  }
+
+  async function uploadDropped(file: File) {
+    setBrowsing(true);
+    setMsg(`Uploading ${file.name}…`);
+    try {
+      const fd = new FormData();
+      fd.append("file", file);
+      const res = await fetch("/api/upload", { method: "POST", body: fd });
+      const d = (await res.json()) as { file_path?: string; error?: string };
+      if (d.file_path) setVideoPath(d.file_path);
+      else setMsg(d.error || "Upload failed");
+    } catch {
+      setMsg("Upload failed");
+    } finally {
+      setBrowsing(false);
+      setMsg(null);
+    }
+  }
+
+  function onDrop(e: React.DragEvent) {
+    e.preventDefault();
+    setDragOver(false);
+    const file = e.dataTransfer.files?.[0];
+    if (file) uploadDropped(file);
+  }
+
+  const detect = () =>
+    call(
+      { action: "new", video_path: videoPath, profile: "auto", format, top_n: topN, min_dur: minDur, max_dur: maxDur },
+      "Finding the best moments (one-time, ~2 min)…",
+    );
+
+  const open = (id: string) => call({ action: "show", session_id: id }, "Loading…");
+
+  const editOp = (index: number, op: string, seconds = 0) =>
+    session &&
+    call({ action: "edit", session_id: session.session_id, index, op, seconds }, "Rebuilding…");
+
+  async function commitTrim(index: number, start: number, end: number) {
+    if (!session) return;
+    setSession({ ...session, moments: session.moments.map((m, i) => (i === index ? { ...m, start, end } : m)) });
+    setSaving(true);
+    try {
+      const r = await api<HighlightsResp>("/reel", {
+        method: "POST",
+        body: JSON.stringify({ action: "edit", session_id: session.session_id, index: index + 1, op: "set", start, end }),
+      });
+      setSession(r);
+    } finally {
+      setSaving(false);
+    }
+  }
+
+  async function remove(e: React.MouseEvent, id: string) {
+    e.stopPropagation();
+    if (!window.confirm("Delete this highlights session?")) return;
+    setBusy(true);
+    try {
+      await api("/reel", { method: "POST", body: JSON.stringify({ action: "delete", session_id: id }) });
+      if (session?.session_id === id) setSession(null);
+      refreshList();
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  const enabled = session?.moments.filter((m) => m.enabled).length ?? 0;
+  const streamSrc = session ? `/api/stream-source?path=${encodeURIComponent(session.source)}` : "";
+  const active = session?.moments[selected];
+
+  return (
+    <div className="app">
+      <div className="header">
+        <h1 style={{ margin: 0 }}>Highlights</h1>
+      </div>
+
+      <div className="section card">
+        <div className="card-title" style={{ marginBottom: 14 }}>Find highlights</div>
+
+        {!videoPath ? (
+          <div
+            className={`drop-zone ${dragOver ? "drag-over" : ""}`}
+            style={{ cursor: browsing ? "default" : "pointer" }}
+            onClick={browsing ? undefined : browse}
+            onDragOver={(e) => { e.preventDefault(); setDragOver(true); }}
+            onDragLeave={() => setDragOver(false)}
+            onDrop={onDrop}
+          >
+            {browsing ? (
+              <div style={{ display: "flex", alignItems: "center", justifyContent: "center", gap: 10 }}>
+                <div className="spinner sm" /> <span style={{ fontSize: 13, fontWeight: 600 }}>Working…</span>
+              </div>
+            ) : (
+              <div className="label"><strong>Browse</strong> or drop a video file here</div>
+            )}
+          </div>
+        ) : (
+          <div className="file-badge fade-in">
+            <div className="dot" />
+            <div className="name">{basename(videoPath)}</div>
+            <button className="btn btn-ghost btn-sm" onClick={() => setVideoPath("")} style={{ padding: "4px 10px", fontSize: 11 }}>
+              Clear
+            </button>
+          </div>
+        )}
+        <input
+          type="text"
+          placeholder="…or paste a local video path"
+          value={videoPath}
+          onChange={(e) => setVideoPath(e.target.value)}
+          style={{ width: "100%", marginTop: 8, fontFamily: "var(--font-mono)", fontSize: 12 }}
+        />
+
+        <div className="row" style={{ marginTop: 14 }}>
+          <Field label="Format">
+            <select value={format} onChange={(e) => setFormat(e.target.value as Format)}>
+              <option value="horizontal">Horizontal 16:9</option>
+              <option value="vertical">Vertical 9:16</option>
+              <option value="square">Square 1:1</option>
+            </select>
+          </Field>
+          <Field label="Moments">
+            <input type="number" min={1} max={50} value={topN} onChange={(e) => setTopN(Number(e.target.value))} style={{ width: "100%" }} />
+          </Field>
+          <Field label="Min length (s)">
+            <input type="number" min={1} value={minDur} onChange={(e) => setMinDur(Number(e.target.value))} style={{ width: "100%" }} />
+          </Field>
+          <Field label="Max length (s)">
+            <input type="number" min={1} value={maxDur} onChange={(e) => setMaxDur(Number(e.target.value))} style={{ width: "100%" }} />
+          </Field>
+        </div>
+
+        <div style={{ display: "flex", justifyContent: "flex-end", marginTop: 16 }}>
+          <button className="btn btn-primary" disabled={busy || !videoPath.trim()} onClick={detect}>
+            {busy && msg?.startsWith("Finding") ? "Finding…" : "Find highlights"}
+          </button>
+        </div>
+      </div>
+
+      {msg && (
+        <div className="set-note" style={{ display: "flex", alignItems: "center", gap: 10, marginBottom: 16 }}>
+          {busy && <div className="spinner sm" />} {msg}
+        </div>
+      )}
+
+      {session ? (
+        <div className="stream-in">
+          <div style={{ display: "flex", alignItems: "center", justifyContent: "space-between", marginBottom: 14 }}>
+            <button className="btn btn-ghost btn-sm" onClick={() => setSession(null)} style={{ display: "inline-flex", alignItems: "center", gap: 6 }}>
+              <BackIcon /> All highlights
+            </button>
+            <div style={{ display: "flex", alignItems: "center", gap: 10 }}>
+              <span className="hint">{enabled}/{session.moments.length} in the cut</span>
+              {session.reel_path && (
+                <a className="btn btn-primary btn-sm" href={download(session.reel_path)} style={{ textDecoration: "none", display: "inline-flex", alignItems: "center", gap: 6 }}>
+                  <DownloadIcon /> Download reel
+                </a>
+              )}
+            </div>
+          </div>
+
+          {active && (
+            <div className="section card" style={{ padding: 16 }}>
+              <div style={{ display: "flex", alignItems: "center", gap: 10, marginBottom: 12 }}>
+                <span className="section-label" style={{ margin: 0 }}>Moment {selected + 1}</span>
+                <span className="pill pill-blue">{active.why}</span>
+                <span className="spacer" style={{ flex: 1 }} />
+                {active.clip_exists && active.clip_path && (
+                  <a className="btn btn-ghost btn-sm" href={download(active.clip_path)} style={{ textDecoration: "none", display: "inline-flex", alignItems: "center", gap: 6 }}>
+                    <DownloadIcon /> Clip
+                  </a>
+                )}
+                <button className="btn btn-ghost btn-sm" disabled={busy} onClick={() => editOp(selected + 1, "toggle")}>
+                  {active.enabled ? "Exclude from cut" : "Include in cut"}
+                </button>
+                <button className="btn btn-danger btn-sm" disabled={busy} onClick={() => editOp(selected + 1, "drop")}>
+                  <TrashIcon />
+                </button>
+              </div>
+              <MomentTrim
+                key={selected}
+                src={streamSrc}
+                moment={active}
+                saving={saving}
+                onCommit={(s, e) => commitTrim(selected, s, e)}
+              />
+              {active.text && <p className="card-desc" style={{ marginTop: 12, marginBottom: 0 }}>{active.text}</p>}
+            </div>
+          )}
+
+          <div className="section-label" style={{ margin: "4px 0 10px" }}>All moments</div>
+          <div style={{ display: "flex", flexDirection: "column", gap: 6 }}>
+            {session.moments.map((m, idx) => (
+              <div
+                key={idx}
+                className="card"
+                onClick={() => setSelected(idx)}
+                style={{
+                  display: "flex", alignItems: "center", gap: 12, padding: "10px 14px", margin: 0, cursor: "pointer",
+                  opacity: m.enabled ? 1 : 0.45,
+                  borderColor: idx === selected ? "var(--accent-edge)" : "var(--border)",
+                }}
+              >
+                <span className="hint" style={{ width: 20, textAlign: "right" }}>{idx + 1}</span>
+                <strong style={{ fontVariantNumeric: "tabular-nums", minWidth: 96 }}>{mmss(m.start)}–{mmss(m.end)}</strong>
+                <span className="pill pill-blue">{m.why}</span>
+                <span className="hint" style={{ marginLeft: "auto", fontVariantNumeric: "tabular-nums" }}>{Math.round(m.end - m.start)}s</span>
+                {m.clip_exists && m.clip_path && (
+                  <a className="btn btn-ghost btn-sm" href={download(m.clip_path)} title="Download clip"
+                    onClick={(e) => e.stopPropagation()} style={{ textDecoration: "none", padding: "4px 8px" }}>
+                    <DownloadIcon size={13} />
+                  </a>
+                )}
+              </div>
+            ))}
+          </div>
+        </div>
+      ) : sessions.length === 0 ? (
+        <div className="empty-state">No highlights yet. Drop in a video above to find its best moments.</div>
+      ) : (
+        <>
+          <div className="section-label" style={{ marginBottom: 12 }}>Saved</div>
+          <div className="stream-in">
+            {sessions.map((s) => (
+              <div
+                key={s.session_id}
+                className="card"
+                style={{ display: "flex", alignItems: "center", gap: 12, padding: 16, cursor: "pointer" }}
+                onClick={() => !busy && open(s.session_id)}
+              >
+                <div style={{ minWidth: 0, flex: 1 }}>
+                  <div className="clip-card-title" style={{ marginBottom: 4 }}>{basename(s.source) || s.session_id}</div>
+                  <div className="meta" style={{ gap: 8 }}>
+                    <span className="pill pill-blue">{s.profile}</span>
+                    <span className="hint">{FORMAT_LABEL[s.format as Format] || s.format}</span>
+                    <span className="hint">·</span>
+                    <span className="hint">{s.enabled_count}/{s.moment_count} moments</span>
+                  </div>
+                </div>
+                <button className="btn btn-ghost btn-sm" disabled={busy} onClick={(e) => { e.stopPropagation(); open(s.session_id); }}>
+                  Open
+                </button>
+                <button className="btn btn-danger btn-sm" title="Delete" disabled={busy} onClick={(e) => remove(e, s.session_id)}>
+                  <TrashIcon />
+                </button>
+              </div>
+            ))}
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/src/ui/client/Layout.tsx b/src/ui/client/Layout.tsx
index be9c231..85737ff 100644
--- a/src/ui/client/Layout.tsx
+++ b/src/ui/client/Layout.tsx
@@ -10,6 +10,7 @@ import {
   Plug,
   Terminal,
   BarChart3,
+  Scissors,
 } from "lucide-react";
 
 const icons: Record<string, typeof LayoutGrid> = {
@@ -22,6 +23,7 @@ const icons: Record<string, typeof LayoutGrid> = {
   integrations: Plug,
   mcp: Terminal,
   analytics: BarChart3,
+  highlights: Scissors,
 };
 
 function Icon({ name }: { name: string }) {
@@ -41,6 +43,7 @@ export default function Layout() {
         <NavLink to="/" end className="sidebar-link"><Icon name="library" /> Library</NavLink>
         <NavLink to="/episode" className="sidebar-link"><Icon name="episode" /> New episode</NavLink>
         <NavLink to="/content" className="sidebar-link"><Icon name="content" /> Content</NavLink>
+        <NavLink to="/highlights" className="sidebar-link"><Icon name="highlights" /> Highlights</NavLink>
         <NavLink to="/thumbnails" className="sidebar-link"><Icon name="thumbnail" /> Thumbnails</NavLink>
 
         <div className="sidebar-section">Workspace</div>
diff --git a/src/ui/client/icons.tsx b/src/ui/client/icons.tsx
index f393b42..55c27ea 100644
--- a/src/ui/client/icons.tsx
+++ b/src/ui/client/icons.tsx
@@ -1,5 +1,5 @@
 import React from "react";
-import { Play, Pause, ChevronLeft, ChevronRight, SkipBack, SkipForward, X, Trash2, ArrowLeft } from "lucide-react";
+import { Play, Pause, ChevronLeft, ChevronRight, SkipBack, SkipForward, X, Trash2, ArrowLeft, Download } from "lucide-react";
 
 const block = { display: "block" } as const;
 
@@ -12,3 +12,4 @@ export const CutBackIcon = () => <SkipBack size={15} style={block} fill="current
 export const CutForwardIcon = () => <SkipForward size={15} style={block} fill="currentColor" />;
 export const CloseIcon = () => <X size={15} style={block} />;
 export const TrashIcon = ({ size = 14 }: { size?: number }) => <Trash2 size={size} style={block} />;
+export const DownloadIcon = ({ size = 14 }: { size?: number }) => <Download size={size} style={block} />;
diff --git a/src/ui/client/main.tsx b/src/ui/client/main.tsx
index bc1ce28..95a451d 100644
--- a/src/ui/client/main.tsx
+++ b/src/ui/client/main.tsx
@@ -7,6 +7,7 @@ import ClipDetail from "./ClipDetail";
 import EpisodeWorkspace from "./EpisodeWorkspace";
 import ThumbnailStudio from "./ThumbnailStudio";
 import ContentStudio from "./ContentStudio";
+import HighlightsPage from "./HighlightsPage";
 import AnalyticsPage from "./AnalyticsPage";
 import KnowledgePage from "./KnowledgePage";
 import ConfigPage from "./ConfigPage";
@@ -21,6 +22,8 @@ createRoot(document.getElementById("root")!).render(
           <Route path="/" element={<StudioHome />} />
           <Route path="/episode" element={<EpisodeWorkspace />} />
           <Route path="/content" element={<ContentStudio />} />
+          <Route path="/highlights" element={<HighlightsPage />} />
+          <Route path="/reel" element={<Navigate to="/highlights" replace />} />
           <Route path="/thumbnails" element={<ThumbnailStudio />} />
           <Route path="/thumbnail" element={<Navigate to="/thumbnails" replace />} />
           <Route path="/clip/:id" element={<ClipDetail />} />
diff --git a/src/ui/web-server.ts b/src/ui/web-server.ts
index d8c8361..432e7e8 100644
--- a/src/ui/web-server.ts
+++ b/src/ui/web-server.ts
@@ -1507,6 +1507,44 @@ app.post("/api/analyze-energy", async (req, res) => {
   }
 });
 
+// --- Highlight reel: detect once, then iterate on moments ---
+app.post("/api/reel", async (req, res) => {
+  try {
+    const result = await executor.execute("manage_reel", req.body || {});
+    const data = (result.data || {}) as any;
+    if (typeof data.source === "string") registerSourcePath(data.source);
+    if (typeof data.reel_path === "string") registerSourcePath(data.reel_path);
+    if (Array.isArray(data.moments)) {
+      for (const m of data.moments) {
+        if (m && typeof m.clip_path === "string" && m.clip_exists) registerSourcePath(m.clip_path);
+      }
+    }
+    res.json(data);
+  } catch (err: any) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+app.get("/api/reel-download", (req, res) => {
+  const filePath = req.query.path as string;
+  if (!filePath) {
+    res.status(400).json({ error: "path required" });
+    return;
+  }
+  let resolved: string;
+  try {
+    resolved = realpathSync(path.resolve(filePath));
+  } catch {
+    res.status(404).json({ error: "File not found" });
+    return;
+  }
+  if (extname(resolved).toLowerCase() !== ".mp4" || !allowedSourcePaths.has(resolved)) {
+    res.status(403).json({ error: "Access denied" });
+    return;
+  }
+  res.download(resolved);
+});
+
 // --- Encoder info ---
 app.get("/api/encoder-info", async (_req, res) => {
   try {
diff --git a/tests/test_reel.py b/tests/test_reel.py
new file mode 100644
index 0000000..643655b
--- /dev/null
+++ b/tests/test_reel.py
@@ -0,0 +1,255 @@
+"""Tests for backend.services.reel session + edit logic (no video/render)."""
+
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+BACKEND_ROOT = os.path.join(ROOT, "backend")
+if BACKEND_ROOT not in sys.path:
+    sys.path.insert(0, BACKEND_ROOT)
+
+from services import reel as R
+
+
+def _session(**kw):
+    return R.ReelSession(
+        session_id=kw.get("sid", "unittest_reel"),
+        source="/tmp/fake.mp4",
+        profile="party",
+        out_dir="/tmp/fake_out",
+        moments=[R.Moment(100.0, 120.0, "energy_peak", "one"),
+                 R.Moment(200.0, 215.0, "reaction", "two")],
+    )
+
+
+class MomentTests(unittest.TestCase):
+    def test_duration(self):
+        self.assertEqual(R.Moment(10.0, 25.0).duration, 15.0)
+
+
+class EditTests(unittest.TestCase):
+    def setUp(self):
+        self.s = _session()
+
+    def tearDown(self):
+        p = R.session_path(self.s.session_id)
+        if os.path.exists(p):
+            os.remove(p)
+
+    def test_longer_extends_end_and_marks_dirty(self):
+        R.edit_moment(self.s, 1, "longer", 10)
+        self.assertEqual(self.s.moments[0].end, 130.0)
+        self.assertTrue(self.s.moments[0].dirty)
+
+    def test_shorter_pulls_end_in(self):
+        R.edit_moment(self.s, 1, "shorter", 5)
+        self.assertEqual(self.s.moments[0].end, 115.0)
+
+    def test_earlier_moves_start_back(self):
+        R.edit_moment(self.s, 1, "earlier", 8)
+        self.assertEqual(self.s.moments[0].start, 92.0)
+
+    def test_shift_moves_both_bounds(self):
+        R.edit_moment(self.s, 2, "shift", -20)
+        self.assertEqual(self.s.moments[1].start, 180.0)
+        self.assertEqual(self.s.moments[1].end, 195.0)
+
+    def test_drop_removes_moment(self):
+        R.edit_moment(self.s, 1, "drop")
+        self.assertEqual(len(self.s.moments), 1)
+        self.assertEqual(self.s.moments[0].text, "two")
+
+    def test_drop_marks_shifted_moments_dirty(self):
+        for m in self.s.moments:
+            m.dirty = False
+        R.edit_moment(self.s, 1, "drop")
+        # The moment that slid into position 1 must re-cut, else it reuses the
+        # dropped moment's clip file.
+        self.assertTrue(self.s.moments[0].dirty)
+
+    def test_toggle_disables_without_removing(self):
+        R.edit_moment(self.s, 1, "toggle")
+        self.assertFalse(self.s.moments[0].enabled)
+        self.assertEqual(len(self.s.moments), 2)
+
+    def test_set_absolute_bounds(self):
+        R.edit_moment(self.s, 1, "set", start=90.5, end=110.4)
+        m = self.s.moments[0]
+        self.assertEqual((m.start, m.end), (90.5, 110.4))
+        self.assertTrue(m.dirty)
+
+    def test_set_start_only_keeps_end(self):
+        R.edit_moment(self.s, 1, "set", start=95.0)
+        self.assertEqual((self.s.moments[0].start, self.s.moments[0].end), (95.0, 120.0))
+
+    def test_set_end_only_keeps_start(self):
+        R.edit_moment(self.s, 1, "set", end=140.0)
+        self.assertEqual((self.s.moments[0].start, self.s.moments[0].end), (100.0, 140.0))
+
+    def test_set_clamps_negative_start(self):
+        R.edit_moment(self.s, 1, "set", start=-5.0)
+        self.assertEqual(self.s.moments[0].start, 0.0)
+
+    def test_set_keeps_end_above_start(self):
+        R.edit_moment(self.s, 1, "set", start=118.0, end=100.0)
+        self.assertGreater(self.s.moments[0].end, self.s.moments[0].start)
+
+    def test_bad_index_raises(self):
+        with self.assertRaises(IndexError):
+            R.edit_moment(self.s, 99, "longer", 5)
+
+    def test_unknown_op_raises(self):
+        with self.assertRaises(ValueError):
+            R.edit_moment(self.s, 1, "flip", 5)
+
+
+class PersistenceTests(unittest.TestCase):
+    def tearDown(self):
+        p = R.session_path("roundtrip_reel")
+        if os.path.exists(p):
+            os.remove(p)
+
+    def test_save_and_load_roundtrip(self):
+        s = _session(sid="roundtrip_reel")
+        s.save()
+        loaded = R.ReelSession.load("roundtrip_reel")
+        self.assertEqual(loaded.session_id, "roundtrip_reel")
+        self.assertEqual(len(loaded.moments), 2)
+        self.assertEqual(loaded.moments[1].why, "reaction")
+        self.assertIsInstance(loaded.moments[0], R.Moment)
+
+    def test_format_defaults_to_horizontal(self):
+        s = _session(sid="roundtrip_reel")
+        s.save()
+        self.assertEqual(R.ReelSession.load("roundtrip_reel").format, "horizontal")
+
+
+class FormatTests(unittest.TestCase):
+    def test_horizontal_pads_to_1920x1080(self):
+        vf = R._scale_filter("horizontal")
+        self.assertIn("1920:1080", vf)
+        self.assertIn("pad=", vf)
+
+    def test_vertical_crops_to_fill(self):
+        vf = R._scale_filter("vertical")
+        self.assertIn("1080:1920", vf)
+        self.assertIn("crop=1080:1920", vf)
+
+    def test_square_crops_to_fill(self):
+        vf = R._scale_filter("square")
+        self.assertIn("crop=1080:1080", vf)
+
+    def test_unknown_format_falls_back(self):
+        self.assertIn("1080:1920", R._scale_filter("bogus"))
+
+
+class SeedSessionTests(unittest.TestCase):
+    def tearDown(self):
+        p = R.session_path("seed_test")
+        if os.path.exists(p):
+            os.remove(p)
+
+    def test_builds_moments_and_stores_format(self):
+        clips = [{"start_second": 10.24, "end_second": 25.71, "reasons": ["laughter"]}]
+        with mock.patch("services.saliency.detect_highlights", return_value=clips):
+            s = R.seed_session("seed_test", "/tmp/v.mp4", "/tmp/o", format="vertical", top_n=5)
+        self.assertEqual(s.format, "vertical")
+        self.assertEqual(len(s.moments), 1)
+        self.assertEqual((s.moments[0].start, s.moments[0].end), (10.2, 25.7))
+        self.assertEqual(s.moments[0].why, "laughter")
+
+    def test_unknown_format_normalized_on_seed(self):
+        with mock.patch("services.saliency.detect_highlights", return_value=[]):
+            s = R.seed_session("seed_test", "/tmp/v.mp4", "/tmp/o", format="bogus")
+        self.assertEqual(s.format, "vertical")
+
+
+class BuildReelTests(unittest.TestCase):
+    def setUp(self):
+        self.dir = tempfile.mkdtemp()
+        self.s = R.ReelSession(
+            "build_test", "/tmp/src.mp4", "auto", self.dir, format="vertical",
+            moments=[R.Moment(10.0, 20.0, "x", "a"), R.Moment(30.0, 45.0, "y", "b")],
+        )
+
+    def tearDown(self):
+        shutil.rmtree(self.dir, ignore_errors=True)
+        p = R.session_path("build_test")
+        if os.path.exists(p):
+            os.remove(p)
+
+    def _build(self):
+        with mock.patch.object(R, "proc_run", return_value=mock.Mock(returncode=0)) as pr:
+            R.build_reel(self.s)
+        return pr
+
+    @staticmethod
+    def _cut_calls(pr):
+        return [c for c in pr.call_args_list if "-vf" in c.args[0]]
+
+    def test_cut_uses_session_format_dimensions(self):
+        pr = self._build()
+        cuts = self._cut_calls(pr)
+        self.assertEqual(len(cuts), 2)
+        for c in cuts:
+            argv = c.args[0]
+            vf = argv[argv.index("-vf") + 1]
+            self.assertIn("1080:1920", vf)
+
+    def test_clean_existing_clips_are_reused(self):
+        clips = os.path.join(self.dir, "clips")
+        os.makedirs(clips, exist_ok=True)
+        for i in (1, 2):
+            open(os.path.join(clips, f"clip_{i:02d}.mp4"), "w").close()
+        for m in self.s.moments:
+            m.dirty = False
+        pr = self._build()
+        self.assertEqual(self._cut_calls(pr), [])
+
+    def test_only_enabled_moments_reach_the_concat(self):
+        self.s.moments[0].enabled = False
+        self._build()
+        with open(os.path.join(self.dir, "_concat.txt")) as f:
+            lines = [ln for ln in f if ln.strip()]
+        self.assertEqual(len(lines), 1)
+
+    def test_drop_then_build_recuts_shifted_moment(self):
+        clips = os.path.join(self.dir, "clips")
+        os.makedirs(clips, exist_ok=True)
+        for i in (1, 2):
+            open(os.path.join(clips, f"clip_{i:02d}.mp4"), "w").close()
+        for m in self.s.moments:
+            m.dirty = False
+        R.edit_moment(self.s, 1, "drop")
+        pr = self._build()
+        self.assertEqual(len(self._cut_calls(pr)), 1)
+
+
+class SessionRegistryTests(unittest.TestCase):
+    _ids = ("registry_a", "registry_b")
+
+    def tearDown(self):
+        for sid in self._ids:
+            p = R.session_path(sid)
+            if os.path.exists(p):
+                os.remove(p)
+
+    def test_list_and_delete(self):
+        for sid in self._ids:
+            _session(sid=sid).save()
+        listed = {s["session_id"] for s in R.list_sessions()}
+        self.assertTrue(set(self._ids) <= listed)
+        summary = next(s for s in R.list_sessions() if s["session_id"] == "registry_a")
+        self.assertEqual(summary["moment_count"], 2)
+        self.assertEqual(summary["enabled_count"], 2)
+        self.assertTrue(R.delete_session("registry_a"))
+        self.assertFalse(R.delete_session("registry_a"))
+        self.assertNotIn("registry_a", {s["session_id"] for s in R.list_sessions()})
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_saliency.py b/tests/test_saliency.py
index 8734ec7..8ed1e3f 100644
--- a/tests/test_saliency.py
+++ b/tests/test_saliency.py
@@ -75,6 +75,22 @@ def test_zero_weight_channel_ignored(self):
         self.assertTrue(np.allclose(fused, 0.0))
 
 
+class ProfileTests(unittest.TestCase):
+    def test_auto_is_a_saliency_profile(self):
+        p = get_profile("auto")
+        self.assertEqual(p.name, "auto")
+        self.assertEqual(p.candidate_source, "saliency")
+
+    def test_auto_fuses_multiple_channels(self):
+        # auto blends audio_event, energy and motion, so any one can drive a peak
+        channels = {"motion": np.array([0.0, 0.0, 5.0]), "energy": np.array([1.0, 1.0, 1.0])}
+        fused = sal.fuse_channels(channels, get_profile("auto"))
+        self.assertEqual(int(np.argmax(fused)), 2)
+
+    def test_unknown_profile_falls_back(self):
+        self.assertEqual(get_profile("nonsense").name, "podcast")
+
+
 class WindowForPeakTests(unittest.TestCase):
     def setUp(self):
         self.energy_flat = np.zeros(200)