@@ -97,12 +97,13 @@ def setup_app():
     from app.routes.fresh_analysis import router as fresh_router
     from app.routes.export import router as export_router
     from app.routes.tools import router as tools_router
+    from app.routes.intelligence import router as intelligence_router
     from app.startup import ensure_admin_user
 
     app = FastAPI(
         title="Music Metadata Engine",
         description="AI-Powered Audio Analysis",
-        version="2.1.0"
+        version="3.0.0"
     )
 
     # Global Exception Handler
@@ -160,6 +161,7 @@ def setup_app():
 
     app.include_router(export_router, prefix="/api")
     app.include_router(tools_router, prefix="/api")
+    app.include_router(intelligence_router, prefix="/api")
     app.include_router(ddex_router, prefix="/api")
     app.include_router(cwr_router, prefix="/api")
     app.include_router(ai_proxy_router, prefix="/api")
@@ -178,7 +180,13 @@ def setup_app():
     async def startup_event_handler():
         logger.info("🚀 Starting application...")
         ensure_admin_user()
-        
+
+        # Load the CLAP hearing model in the background so the first analysis does not pay for it
+        # (first start downloads ~600 MB into /data/hf - the persistent volume)
+        import threading
+        from app.services import hearing as _hearing
+        threading.Thread(target=_hearing.available, name="hearing-preload", daemon=True).start()
+
         # Start cleanup task
         asyncio.create_task(cleanup_temp_files())
 
 
@@ -71,6 +71,8 @@ def get_db():
     "acousticScore",
     "hasVocals",
     "genreCorrected",
+    # Engine 3.0
+    "hearing", "trust", "passport", "syncReadiness", "technical", "sonicVector", "tempoAnalysis",
     # Misc
     "analysisReasoning",
     "similar_artists",
@@ -256,6 +258,16 @@ def remaining() -> float:
         await ws_manager.send_progress(job_id, job.message, progress=20)
 
         from app.services.fresh_track_analyzer import FreshTrackAnalyzer
+        from app.services import qc as qc_mod
+
+        def _safe_qc(path):
+            try:
+                return qc_mod.analyze_file(path)
+            except Exception as qe:  # noqa: BLE001 - QC is an extra, never fail the analysis for it
+                logger.warning(f"Job {job_id}: QC failed: {qe}")
+                return None
+
+        qc_task = asyncio.get_running_loop().run_in_executor(None, _safe_qc, file_path)
         analyzer = FreshTrackAnalyzer()
         analyzer_budget = max(15, int(remaining() - 2.0))
 
@@ -314,6 +326,22 @@ def remaining() -> float:
         except Exception as e:
             logger.warning(f"Could not read existing file tags: {e}")
 
+        # Technical QC (ran in parallel) + signed passport
+        try:
+            qc_report = await asyncio.wait_for(qc_task, timeout=120)
+        except Exception as qe:  # noqa: BLE001
+            logger.warning(f"Job {job_id}: QC unavailable: {qe}")
+            qc_report = None
+        if qc_report:
+            metadata["syncReadiness"] = qc_report.pop("syncReadiness", None)
+            metadata["technical"] = qc_report
+        try:
+            from app.services import passport as passport_mod
+            metadata["passport"] = passport_mod.build_passport(
+                metadata, metadata.get("trust"), (metadata.get("hearing") or {}).get("model"))
+        except Exception as pe:  # noqa: BLE001
+            logger.warning(f"Job {job_id}: passport not issued: {pe}")
+
         job.message = "Sanitizing and validating metadata..."
         db.commit()
         await ws_manager.send_progress(job_id, job.message, progress=85)
 
@@ -0,0 +1,136 @@
+"""Engine 3.0 endpoints: QC, smart cutdowns, hearing, sonic similarity, signed passports."""
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import tempfile
+from contextlib import contextmanager
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+from fastapi import APIRouter, Body, Depends, File, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+from starlette.background import BackgroundTask
+
+from app.dependencies import get_user_and_check_quota
+from app.services import cutdowns, hearing, passport, qc
+
+router = APIRouter(prefix="/intelligence", tags=["intelligence"])
+ALLOWED = {".mp3", ".wav", ".flac", ".m4a", ".aac", ".ogg"}
+MAX_BYTES = 200 * 1024 * 1024
+
+
+@contextmanager
+def _spooled(upload: UploadFile):
+    ext = os.path.splitext(upload.filename or "")[1].lower()
+    if ext not in ALLOWED:
+        raise HTTPException(400, f"Unsupported file type: {ext or 'none'}")
+    d = tempfile.mkdtemp(prefix="intel_")
+    path = os.path.join(d, "audio" + ext)
+    try:
+        written = 0
+        with open(path, "wb") as f:
+            while chunk := upload.file.read(1024 * 1024):
+                written += len(chunk)
+                if written > MAX_BYTES:
+                    raise HTTPException(413, "File too large (limit 200 MB)")
+                f.write(chunk)
+        yield path
+    finally:
+        shutil.rmtree(d, ignore_errors=True)
+
+
+async def _off_loop(fn, *a):
+    return await asyncio.get_running_loop().run_in_executor(None, fn, *a)
+
+
+@router.post("/qc")
+async def technical_qc(file: UploadFile = File(...), user=Depends(get_user_and_check_quota)) -> Dict[str, Any]:
+    """Loudness (LUFS / true peak), clipping, lossy-origin test, head/tail silence, ending style, sync-readiness score."""
+    with _spooled(file) as path:
+        return await _off_loop(qc.analyze_file, path)
+
+
+@router.post("/cutdowns")
+async def plan_cutdowns(file: UploadFile = File(...), targets: str = Form("15,30,60"), user=Depends(get_user_and_check_quota)) -> Dict[str, Any]:
+    """Bar/phrase-aligned 15/30/60 s edit proposals (an 'intro' cut and a 'hook' cut per length)."""
+    try:
+        wanted = sorted({int(t) for t in targets.split(",") if t.strip()})
+    except ValueError:
+        raise HTTPException(400, "targets must be comma-separated seconds, e.g. 15,30,60")
+    if not wanted or any(t < 5 or t > 180 for t in wanted):
+        raise HTTPException(400, "each target must be 5-180 seconds")
+    with _spooled(file) as path:
+        return await _off_loop(cutdowns.plan_file, path, wanted)
+
+
+@router.post("/cutdowns/render")
+async def render_cutdown(file: UploadFile = File(...), start: float = Form(...), end: float = Form(...), fade_out: float = Form(1.0),
+                         format: str = Form("mp3"), user=Depends(get_user_and_check_quota)):
+    """Render one proposed cut (start/end from /cutdowns) with a 20 ms fade-in and a musical fade-out."""
+    if not (0 <= start < end) or end - start > 300 or format not in ("mp3", "wav"):
+        raise HTTPException(400, "invalid cut")
+    ext = os.path.splitext(file.filename or "")[1].lower()
+    if ext not in ALLOWED:
+        raise HTTPException(400, f"Unsupported file type: {ext or 'none'}")
+    d = tempfile.mkdtemp(prefix="cut_")
+    src, out = os.path.join(d, "src" + ext), os.path.join(d, f"cutdown.{format}")
+    with open(src, "wb") as f:
+        shutil.copyfileobj(file.file, f)
+    try:
+        await _off_loop(cutdowns.render, src, start, end, max(0.0, min(fade_out, 8.0)), out)
+    except Exception:
+        shutil.rmtree(d, ignore_errors=True)
+        raise HTTPException(500, "render failed")
+    return FileResponse(out, media_type="audio/mpeg" if format == "mp3" else "audio/wav", filename=f"cutdown_{int(end - start)}s.{format}",
+                        background=BackgroundTask(shutil.rmtree, d, True))
+
+
+@router.post("/hear")
+async def hear(file: UploadFile = File(...), vector: bool = Form(False), user=Depends(get_user_and_check_quota)) -> Dict[str, Any]:
+    """What the audio model hears: genre / mood / instruments / singer verdict (+ optional 512-d sonic vector)."""
+    with _spooled(file) as path:
+        res = await _off_loop(hearing.listen, path)
+    if not res:
+        raise HTTPException(503, "Hearing model unavailable")
+    if not vector:
+        res.pop("sonicVector", None)
+    return res
+
+
+@router.post("/similar")
+async def similar(payload: Dict[str, Any] = Body(...)) -> Dict[str, Any]:
+    """Rank candidates by audio similarity. Body: {"vector": b64, "candidates": [{"id": ..., "vector": b64}], "top": 10}.
+    Vectors come from the analysis result (``sonicVector``). Cosine >= 0.97 usually means the same recording / another master."""
+    try:
+        q = hearing.unpack_vector(payload["vector"])
+        cands = payload["candidates"]
+    except (KeyError, ValueError, TypeError):
+        raise HTTPException(400, "vector and candidates are required")
+    if len(cands) > 20000:
+        raise HTTPException(413, "too many candidates")
+    scored: List[Dict[str, Any]] = []
+    for c in cands:
+        try:
+            s = hearing.cosine(q, hearing.unpack_vector(c["vector"]))
+        except (KeyError, ValueError, TypeError):
+            continue
+        scored.append({"id": c.get("id"), "similarity": round(s, 4), "likelyDuplicate": s >= 0.97})
+    scored.sort(key=lambda x: -x["similarity"])
+    return {"results": scored[: int(payload.get("top", 10))]}
+
+
+@router.get("/passport/public-key")
+async def passport_public_key() -> Dict[str, Any]:
+    return {"alg": "Ed25519", "publicKey": passport.public_key_b64(), "keyId": passport.key_id(),
+            "engine": passport.ENGINE_NAME, "version": passport.ENGINE_VERSION}
+
+
+@router.post("/passport/verify")
+async def passport_verify(payload: Dict[str, Any] = Body(...)) -> Dict[str, Any]:
+    """Body: the ``passport`` object from an analysis result (optional ``publicKey`` to verify against another engine's key)."""
+    p = payload.get("passport", payload)
+    if not isinstance(p, dict) or "payload" not in p:
+        raise HTTPException(400, "passport object expected")
+    return passport.verify_passport(p, payload.get("publicKey"))
@@ -0,0 +1,131 @@
+"""Smart cutdowns: 15 / 30 / 60 s edits cut on bar and phrase boundaries with a musical ending.
+
+Sync buyers always ask for cutdowns. Naive trimming (first N seconds) stops mid-phrase on a random beat. This planner
+works on the beat grid: it groups beats into bars, finds the phrase structure (4/8-bar blocks counted from where the
+track actually starts), and for each target length proposes
+  * ``intro`` - from the start of the music, ending on the bar closest to the target with a one-bar fade;
+  * ``hook``  - the most energetic phrase-aligned window of that length, which ends where the energy naturally drops.
+Pure planning (``plan_cutdowns``) is unit-tested with synthetic grids; ``beat_grid`` and ``render`` use librosa/ffmpeg.
+"""
+from __future__ import annotations
+
+import subprocess
+from typing import Any, Dict, List, Optional, Sequence
+
+import numpy as np
+
+
+def _bars(beat_times: np.ndarray, beat_energy: np.ndarray, per_bar: int):
+    n = (len(beat_times) // per_bar) * per_bar
+    starts = beat_times[:n:per_bar]
+    energy = beat_energy[:n].reshape(-1, per_bar).mean(axis=1)
+    return starts, energy
+
+
+def plan_cutdowns(beat_times: Sequence[float], beat_energy: Sequence[float], duration: float,
+                  targets: Sequence[int] = (15, 30, 60), per_bar: int = 4) -> Dict[str, Any]:
+    bt, be = np.asarray(beat_times, dtype=float), np.asarray(beat_energy, dtype=float)
+    if bt.size < per_bar * 4 or duration <= 0:
+        return {"ok": False, "reason": "not enough beats to plan cutdowns", "cutdowns": []}
+    beat_dur = float(np.median(np.diff(bt)))
+    bar_dur = beat_dur * per_bar
+    starts, energy = _bars(bt, be, per_bar)
+    if starts.size < 4:
+        return {"ok": False, "reason": "too short", "cutdowns": []}
+    # end time of bar i = start of bar i+1; the last bar ends at the end of the audio
+    ends = np.append(starts[1:], min(duration, starts[-1] + bar_dur))
+    med = float(np.median(energy)) or 1e-9
+    body = int(np.argmax(energy > 0.5 * med))                     # first bar with real music
+    p75 = float(np.percentile(energy, 90)) or 1e-9          # reference level of the loud sections
+    out: List[Dict[str, Any]] = []
+    for target in targets:
+        n = max(2, int(round(target / bar_dur)))
+        if n >= starts.size:
+            continue
+        # option 1: intro cut
+        s0 = body
+        e0 = min(starts.size - 1, s0 + n - 1)
+        intro = _cut("intro", target, starts, ends, energy, s0, e0, bar_dur, body, p75, duration)
+        # option 2: best hook window
+        best = None
+        for s in range(0, starts.size - n + 1):
+            e = s + n - 1
+            c = _cut("hook", target, starts, ends, energy, s, e, bar_dur, body, p75, duration)
+            if best is None or c["score"] > best["score"]:
+                best = c
+        out.append({"target": target, "options": [x for x in (intro, best) if x]})
+    return {"ok": True, "bar_seconds": round(bar_dur, 3), "bpm": round(60 / beat_dur, 1), "first_music_bar": body, "cutdowns": out}
+
+
+def _cut(kind: str, target: int, starts, ends, energy, s: int, e: int, bar_dur: float, body: int, p75: float, duration: float) -> Dict[str, Any]:
+    start, end = float(starts[s]), float(ends[e])
+    dur = end - start
+    phrase = ((s - body) % 8 == 0) * 1.0 + (((s - body) % 4 == 0) * 0.5)         # aligned to 8/4-bar phrases
+    prev = energy[max(0, s - 2):s]
+    if prev.size and energy[s] > 1.2 * prev.mean():                            # the section itself starts here (energy jump)
+        phrase = max(phrase, 1.0)
+    hook = float(np.clip(energy[s:e + 1].mean() / p75, 0, 1.2))
+    drop_at_end = e + 1 < energy.size and energy[e] > 0 and energy[e + 1] < 0.9 * energy[e]
+    natural = bool(e >= energy.size - 1 or drop_at_end)
+    length_fit = 1.0 - min(1.0, abs(dur - target) / target)
+    score = round(0.45 * hook + 0.25 * phrase + 0.2 * length_fit + 0.1 * (1.0 if natural else 0.0), 3)
+    fade = 0.0 if (natural and e >= energy.size - 1) else round(min(bar_dur, 3.0), 2)
+    return {"kind": kind, "start": round(start, 3), "end": round(end, 3), "duration": round(dur, 3), "bars": e - s + 1,
+            "fadeOut": fade, "naturalEnd": natural, "phraseAligned": phrase >= 1.0, "score": score,
+            "reason": ("starts where the music starts, ends on a bar line" if kind == "intro"
+                       else "most energetic phrase-aligned window" + (", ends where energy drops" if natural else ""))}
+
+
+def align_beats_to_tempo(beats: Sequence[float], bpm: float) -> np.ndarray:
+    """Make the beat grid agree with the consensus tempo: a tracker locked to half-time gets midpoints inserted,
+    one locked to double-time keeps every second beat."""
+    b = np.asarray(beats, dtype=float)
+    if b.size < 4 or not bpm:
+        return b
+    ratio = float(np.median(np.diff(b))) / (60.0 / bpm)
+    if 1.85 <= ratio <= 2.15:                                   # beats are twice as far apart as the tempo says
+        mid = (b[:-1] + b[1:]) / 2
+        return np.sort(np.concatenate([b, mid]))
+    if 0.45 <= ratio <= 0.55:                                   # beats are twice as dense
+        return b[::2]
+    return b
+
+
+# ───────────────────────────── audio side ─────────────────────────────
+def beat_grid(path: str, sr: int = 22050) -> Dict[str, Any]:
+    import librosa
+
+    from . import tempo as tempo_mod
+
+    y, _ = librosa.load(path, sr=sr, mono=True)
+    duration = y.size / sr
+    est = tempo_mod.estimate_file(path)
+    beat_times = np.asarray(est.get("beats") or [])
+    if beat_times.size >= 16 and est.get("bpm"):
+        beat_times = align_beats_to_tempo(beat_times, est["bpm"])
+    else:
+        _, beats = librosa.beat.beat_track(y=y, sr=sr)
+        beat_times = librosa.frames_to_time(beats, sr=sr)
+    rms = librosa.feature.rms(y=y, hop_length=512)[0]
+    frame_t = librosa.frames_to_time(np.arange(rms.size), sr=sr, hop_length=512)
+    idx = np.searchsorted(frame_t, np.append(beat_times, duration))
+    energy = np.array([rms[idx[i]:max(idx[i] + 1, idx[i + 1])].mean() for i in range(len(beat_times))]) if len(beat_times) else np.array([])
+    return {"beat_times": beat_times, "beat_energy": energy, "duration": duration, "tempo": est}
+
+
+def plan_file(path: str, targets: Sequence[int] = (15, 30, 60)) -> Dict[str, Any]:
+    g = beat_grid(path)
+    plan = plan_cutdowns(g["beat_times"], g["beat_energy"], g["duration"], targets)
+    plan["duration_s"] = round(g["duration"], 2)
+    t = g.get("tempo") or {}
+    plan["tempo"] = {k: t.get(k) for k in ("bpm", "agreement", "alternatives", "octaveAmbiguous")}
+    return plan
+
+
+def render(path: str, start: float, end: float, fade_out: float, out_path: str, bitrate: str = "320k") -> str:
+    dur = end - start
+    af = f"afade=t=in:st=0:d=0.02,afade=t=out:st={max(0.0, dur - fade_out):.3f}:d={fade_out:.3f}" if fade_out > 0 else "afade=t=in:st=0:d=0.02"
+    codec = ["-c:a", "libmp3lame", "-b:a", bitrate] if out_path.lower().endswith(".mp3") else []
+    subprocess.run(["ffmpeg", "-v", "error", "-y", "-ss", f"{start:.3f}", "-t", f"{dur:.3f}", "-i", path, "-af", af, *codec, out_path],
+                   check=True, capture_output=True, timeout=300)
+    return out_path