diff --git a/frontend/src/app/settings/page.tsx b/frontend/src/app/settings/page.tsx
index 3608a93..656b82f 100644
--- a/frontend/src/app/settings/page.tsx
+++ b/frontend/src/app/settings/page.tsx
@@ -104,6 +104,10 @@ export default function SettingsPage() {
   const [consolidateResult, setConsolidateResult] = useState("");
   const fileInputRef = useRef<HTMLInputElement>(null);
 
+  // Full audit export (memories + entity graph + trust + conflicts)
+  const [fullExportBusy, setFullExportBusy] = useState<"" | "json" | "sqlite" | "pdf">("");
+  const [fullExportError, setFullExportError] = useState("");
+
   // Backup & restore
   const [backupPass, setBackupPass] = useState("");
   const [backingUp, setBackingUp] = useState(false);
@@ -242,6 +246,23 @@ export default function SettingsPage() {
     setImportingJson(false);
   };
 
+  const downloadFullExport = async (format: "json" | "sqlite" | "pdf") => {
+    setFullExportBusy(format);
+    setFullExportError("");
+    try {
+      const { blob, filename } = await api.exportFull(format);
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = filename;
+      a.click();
+      URL.revokeObjectURL(url);
+    } catch (e) {
+      setFullExportError(e instanceof Error ? e.message : String(e));
+    }
+    setFullExportBusy("");
+  };
+
   const downloadBackup = async () => {
     setBackingUp(true);
     try {
@@ -947,6 +968,54 @@ export default function SettingsPage() {
             />
           </div>
 
+          <div className="pt-2 border-t space-y-1">
+            <p className="text-xs text-muted-foreground">
+              Full audit export — memories, entity graph, trust scores, and conflict candidates
+              in one file. For auditing or backing up everything, not just memories.
+            </p>
+            <div className="flex flex-wrap items-center gap-2">
+              <Button
+                variant="outline"
+                onClick={() => downloadFullExport("json")}
+                disabled={fullExportBusy !== ""}
+              >
+                {fullExportBusy === "json" ? (
+                  <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                ) : (
+                  <Download className="h-4 w-4 mr-2" />
+                )}
+                Full export (JSON)
+              </Button>
+              <Button
+                variant="outline"
+                onClick={() => downloadFullExport("sqlite")}
+                disabled={fullExportBusy !== ""}
+              >
+                {fullExportBusy === "sqlite" ? (
+                  <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                ) : (
+                  <Download className="h-4 w-4 mr-2" />
+                )}
+                Full export (SQLite)
+              </Button>
+              <Button
+                variant="outline"
+                onClick={() => downloadFullExport("pdf")}
+                disabled={fullExportBusy !== ""}
+              >
+                {fullExportBusy === "pdf" ? (
+                  <Loader2 className="h-4 w-4 mr-2 animate-spin" />
+                ) : (
+                  <Download className="h-4 w-4 mr-2" />
+                )}
+                Audit report (PDF)
+              </Button>
+            </div>
+            {fullExportError && (
+              <span className="text-xs text-destructive">{fullExportError}</span>
+            )}
+          </div>
+
           <div className="flex flex-wrap items-center gap-2 pt-2 border-t">
             <Button variant="outline" onClick={runConsolidate} disabled={consolidateBusy}>
               {consolidateBusy && <Loader2 className="h-4 w-4 mr-2 animate-spin" />}
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index 3d3f9d4..f871ac7 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -376,6 +376,27 @@ export const api = {
       body: JSON.stringify({ content_b64, passphrase: passphrase || "", replace }),
     }),
 
+  // Full export — memories + entity graph + trust scores + conflicts.
+  // Binary response, so raw fetch (not fetchApi).
+  exportFull: async (format: "json" | "sqlite" | "pdf"): Promise<{ blob: Blob; filename: string }> => {
+    const token = getToken();
+    const res = await fetch(`${API}/api/export/full.${format}`, {
+      headers: token ? { "X-LEVH-Token": token } : {},
+    });
+    if (!res.ok) {
+      let detail = `${res.status}`;
+      try {
+        const body = await res.json();
+        if (body?.detail) detail = `${res.status}: ${body.detail}`;
+      } catch {}
+      throw new Error(`API error ${detail}`);
+    }
+    const disposition = res.headers.get("Content-Disposition") || "";
+    const match = disposition.match(/filename="([^"]+)"/);
+    const filename = match ? match[1] : `levh-full-export.${format}`;
+    return { blob: await res.blob(), filename };
+  },
+
   // Context
   generateContextFile: (project: string | null, style: "claude" | "cursor") =>
     fetchApi<{ filename: string; content: string }>("/api/context-file", {
diff --git a/pyproject.toml b/pyproject.toml
index 9cadc95..af60a10 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -37,7 +37,9 @@ openai = []
 # Passphrase-encrypted backups. Bundled in core deps too; this extra is a
 # convenience alias for anyone pinning security features explicitly.
 secure = ["cryptography>=42"]
-dev = ["pytest", "pytest-asyncio", "build", "twine"]
+# PDF rendering for the full-export audit report.
+pdf = ["fpdf2>=2.7"]
+dev = ["pytest", "pytest-asyncio", "build", "twine", "fpdf2>=2.7"]
 
 [project.urls]
 Homepage = "https://levh.ai-ulu.com/"
diff --git a/server/api.py b/server/api.py
index 4ba27fc..00f5a1a 100644
--- a/server/api.py
+++ b/server/api.py
@@ -1101,6 +1101,69 @@ async def import_memories(req: ImportRequest):
     return await engine.import_memories_gated(req.data)
 
 
+# ── Full export (memories + entity graph + trust + conflicts) ──────
+
+
+def _export_filename(ext: str) -> str:
+    from datetime import datetime, timezone
+
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+    return f"levh-full-export-{stamp}.{ext}"
+
+
+@app.get("/api/export/full.json")
+async def export_full_json():
+    """One-shot audit bundle: memories, entity graph, trust scores, and
+    conflict candidates — the raw machine-readable record."""
+    from server.core.full_export import build_full_export
+
+    engine = await get_engine()
+    export = await build_full_export(engine)
+    import json as _json
+
+    return Response(
+        content=_json.dumps(export, default=str),
+        media_type="application/json",
+        headers={"Content-Disposition": f'attachment; filename="{_export_filename("json")}"'},
+    )
+
+
+@app.get("/api/export/full.sqlite")
+async def export_full_sqlite():
+    """Raw SQLite copy of the live database, taken via the online backup API."""
+    from server.core.full_export import export_full_sqlite as export_sqlite
+
+    engine = await get_engine()
+    try:
+        blob = await export_sqlite(engine)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+    return Response(
+        content=blob,
+        media_type="application/vnd.sqlite3",
+        headers={"Content-Disposition": f'attachment; filename="{_export_filename("sqlite")}"'},
+    )
+
+
+@app.get("/api/export/full.pdf")
+async def export_full_pdf():
+    """Human-readable audit report (summary counts, entity/trust/conflict
+    overview) rendered from the same data as the JSON export."""
+    from server.core.full_export import PdfUnavailableError, build_full_export, render_full_export_pdf
+
+    engine = await get_engine()
+    export = await build_full_export(engine)
+    try:
+        blob = render_full_export_pdf(export)
+    except PdfUnavailableError as exc:
+        raise HTTPException(status_code=503, detail=str(exc))
+    return Response(
+        content=blob,
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="{_export_filename("pdf")}"'},
+    )
+
+
 # ── Backup / Restore (Faz 0 security) ───────────────────────────────
 
 
diff --git a/server/cli.py b/server/cli.py
index e6089c7..8cda230 100644
--- a/server/cli.py
+++ b/server/cli.py
@@ -1229,6 +1229,58 @@ async def _run() -> dict:
     return 0
 
 
+def cmd_export_full(args: argparse.Namespace) -> int:
+    """Export memories + entity graph + trust scores + conflicts to one file."""
+    import asyncio
+
+    from server.core import engine_provider
+
+    fmt = args.format
+    out_path = args.out or f"levh-full-export.{fmt}"
+
+    async def _run():
+        engine = engine_provider.get_engine()
+        await engine.initialize()
+        try:
+            from server.core.full_export import (
+                PdfUnavailableError,
+                build_full_export,
+                export_full_sqlite,
+                render_full_export_pdf,
+            )
+
+            if fmt == "json":
+                import json
+
+                export = await build_full_export(engine)
+                with open(out_path, "w") as f:
+                    json.dump(export, f, indent=2, default=str)
+                return export["counts"]
+            elif fmt == "sqlite":
+                blob = await export_full_sqlite(engine)
+                with open(out_path, "wb") as f:
+                    f.write(blob)
+                return None
+            else:
+                export = await build_full_export(engine)
+                try:
+                    blob = render_full_export_pdf(export)
+                except PdfUnavailableError as exc:
+                    print(f"  {exc}", file=sys.stderr)
+                    return None
+                with open(out_path, "wb") as f:
+                    f.write(blob)
+                return export["counts"]
+        finally:
+            await engine.shutdown()
+
+    counts = asyncio.run(_run())
+    if counts is None and fmt == "pdf":
+        return 1
+    print(f"  Wrote {out_path}" + (f" — {counts}" if counts else ""))
+    return 0
+
+
 def cmd_remove_demo(args: argparse.Namespace) -> int:
     """Remove all demo-tagged memories, leaving real data untouched."""
     import asyncio
@@ -1605,6 +1657,19 @@ def main() -> int:
         help="Remove demo-tagged memories, leaving real data untouched",
     )
 
+    # export-full (memories + entity graph + trust + conflicts, one file)
+    export_full_p = sub.add_parser(
+        "export-full",
+        help="Export memories, entity graph, trust scores, and conflicts to one file",
+    )
+    export_full_p.add_argument(
+        "--format",
+        choices=["json", "sqlite", "pdf"],
+        default="json",
+        help="Output format (default: json)",
+    )
+    export_full_p.add_argument("--out", help="Output file path (default: levh-full-export.<format>)")
+
     # entities (persistent entity knowledge graph)
     ent_p = sub.add_parser("entities", help="Persistent entity knowledge graph")
     ent_sub = ent_p.add_subparsers(dest="entities_command")
@@ -1685,6 +1750,8 @@ def main() -> int:
         return cmd_seed_demo(args)
     elif args.command == "remove-demo":
         return cmd_remove_demo(args)
+    elif args.command == "export-full":
+        return cmd_export_full(args)
     elif args.command == "entities":
         if args.entities_command in ("reindex", "list", "about"):
             return cmd_entities(args)
diff --git a/server/core/database.py b/server/core/database.py
index c6e5d1b..23668d6 100644
--- a/server/core/database.py
+++ b/server/core/database.py
@@ -1051,6 +1051,15 @@ async def list_low_trust(self, threshold: float = 0.4, limit: int = 50) -> list[
         await cursor.close()
         return [dict(r) for r in rows]
 
+    async def list_all_trust(self, limit: int = 1_000_000) -> list[dict]:
+        cursor = await self.conn.execute(
+            "SELECT * FROM memory_trust_scores ORDER BY confidence ASC LIMIT ?",
+            (limit,),
+        )
+        rows = await cursor.fetchall()
+        await cursor.close()
+        return [dict(r) for r in rows]
+
     async def clear_trust(self) -> None:
         await self.conn.execute("DELETE FROM memory_trust_scores")
         await self.conn.commit()
diff --git a/server/core/full_export.py b/server/core/full_export.py
new file mode 100644
index 0000000..189d19c
--- /dev/null
+++ b/server/core/full_export.py
@@ -0,0 +1,158 @@
+"""Full audit export — memories + entity graph + trust scores + conflict
+candidates in one bundle, for local-first backup/auditability.
+
+Three output shapes share one data-gathering pass:
+- JSON: the raw structured bundle, machine-readable.
+- SQLite: a consistent online-backup copy of the live database file.
+- PDF: a short human-readable summary derived from the same JSON bundle.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+FORMAT_VERSION = 1
+
+
+class PdfUnavailableError(RuntimeError):
+    """Raised when the optional ``fpdf2`` dependency isn't installed."""
+
+
+async def build_full_export(engine: Any) -> dict:
+    """Gather memories, entities, trust scores, and conflict candidates."""
+    memories = await engine.export_memories()
+    entities = await engine.list_entities_graph(limit=100_000)
+    entity_stats = await engine.entity_graph_stats()
+    trust = await engine.list_all_trust(limit=1_000_000)
+    conflicts = await engine.list_conflict_candidates(status=None, limit=1000)
+
+    return {
+        "format": "levh-full-export",
+        "version": FORMAT_VERSION,
+        "created_at": datetime.now(timezone.utc).isoformat(),
+        "counts": {
+            "memories": len(memories),
+            "entities": len(entities),
+            "trust_scores": len(trust),
+            "conflicts": len(conflicts),
+        },
+        "memories": memories,
+        "entities": entities,
+        "entity_stats": entity_stats,
+        "trust": trust,
+        "conflicts": conflicts,
+    }
+
+
+async def export_full_sqlite(engine: Any) -> bytes:
+    """Return a consistent SQLite snapshot of the live database as bytes.
+
+    Uses SQLite's online backup API (via ``Database.create_safety_backup``)
+    so WAL pages are captured correctly even against a live connection.
+    """
+    import tempfile
+
+    with tempfile.TemporaryDirectory() as tmp:
+        target = Path(tmp) / "levh-export.sqlite"
+        path = await engine.db.create_safety_backup(str(target))
+        if path is None:
+            raise ValueError("Cannot export an in-memory database as SQLite")
+        return Path(path).read_bytes()
+
+
+def _confidence_bucket(score: float) -> str:
+    if score < 0.4:
+        return "low (<0.4)"
+    if score < 0.7:
+        return "medium (0.4-0.7)"
+    return "high (0.7-1.0)"
+
+
+def render_full_export_pdf(export: dict) -> bytes:
+    """Render a short human-readable audit report from the export bundle."""
+    try:
+        from fpdf import FPDF
+        from fpdf.enums import XPos, YPos
+    except ImportError as exc:
+        raise PdfUnavailableError(
+            "PDF export needs the optional 'fpdf2' package. "
+            "Install it with:  pip install fpdf2   (or: pip install "
+            "'levh[pdf]'). JSON and SQLite export work without it."
+        ) from exc
+
+    pdf = FPDF()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.add_page()
+
+    pdf.set_font("Helvetica", "B", 16)
+    pdf.cell(0, 10, "LEVH - Full Export Audit Report", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.set_font("Helvetica", "", 10)
+    pdf.cell(0, 6, f"Generated: {export['created_at']}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.ln(4)
+
+    counts = export["counts"]
+    pdf.set_font("Helvetica", "B", 12)
+    pdf.cell(0, 8, "Summary", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.set_font("Helvetica", "", 10)
+    for label, key in (
+        ("Memories", "memories"),
+        ("Entities", "entities"),
+        ("Trust scores", "trust_scores"),
+        ("Conflict candidates", "conflicts"),
+    ):
+        pdf.cell(0, 6, f"  {label}: {counts[key]}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.ln(4)
+
+    pdf.set_font("Helvetica", "B", 12)
+    pdf.cell(0, 8, "Entities by type", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.set_font("Helvetica", "", 10)
+    by_type = export.get("entity_stats", {}).get("by_type", {})
+    if by_type:
+        for etype, count in by_type.items():
+            pdf.cell(0, 6, f"  {etype}: {count}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    else:
+        pdf.cell(0, 6, "  (none)", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.ln(4)
+
+    pdf.set_font("Helvetica", "B", 12)
+    pdf.cell(0, 8, "Trust score distribution", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.set_font("Helvetica", "", 10)
+    buckets: dict[str, int] = {}
+    for row in export.get("trust", []):
+        buckets[_confidence_bucket(row.get("confidence", 0))] = (
+            buckets.get(_confidence_bucket(row.get("confidence", 0)), 0) + 1
+        )
+    if buckets:
+        for bucket in ("low (<0.4)", "medium (0.4-0.7)", "high (0.7-1.0)"):
+            if bucket in buckets:
+                pdf.cell(0, 6, f"  {bucket}: {buckets[bucket]}", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    else:
+        pdf.cell(0, 6, "  (no trust scores computed yet)", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.ln(4)
+
+    pdf.set_font("Helvetica", "B", 12)
+    open_conflicts = [c for c in export.get("conflicts", []) if c.get("status") == "open"]
+    pdf.cell(0, 8, f"Open conflict candidates ({len(open_conflicts)})", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.set_font("Helvetica", "", 9)
+    if open_conflicts:
+        for c in open_conflicts[:50]:
+            line = f"  [{c.get('signal_type', '?')}] {c.get('memory_id_a', '')[:8]} vs {c.get('memory_id_b', '')[:8]}"
+            pdf.multi_cell(0, 5, line)
+        if len(open_conflicts) > 50:
+            pdf.cell(0, 6, f"  ... and {len(open_conflicts) - 50} more", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    else:
+        pdf.cell(0, 6, "  (none)", new_x=XPos.LMARGIN, new_y=YPos.NEXT)
+    pdf.ln(4)
+
+    pdf.set_font("Helvetica", "I", 8)
+    pdf.multi_cell(
+        0,
+        5,
+        "This PDF is a human-readable summary. The JSON or SQLite export from "
+        "the same endpoint is the canonical, complete machine-readable record.",
+    )
+
+    out = pdf.output()
+    return bytes(out)
diff --git a/server/core/memory_engine.py b/server/core/memory_engine.py
index 2903ed8..2fecb12 100644
--- a/server/core/memory_engine.py
+++ b/server/core/memory_engine.py
@@ -2453,6 +2453,11 @@ async def list_low_trust(self, threshold: float = 0.4, limit: int = 50) -> list[
             limit=limit,
         )
 
+    async def list_all_trust(self, limit: int = 1_000_000) -> list[dict]:
+        """Return every stored trust breakdown, best score first."""
+        await self._ensure_derived_state()
+        return await self.trust_service.list_all_trust(limit=limit)
+
     # ── Conflict candidates (deterministic review signal) ─────────
 
     async def detect_conflict_candidates(self) -> dict:
diff --git a/server/core/trust_service.py b/server/core/trust_service.py
index 259536c..67b222d 100644
--- a/server/core/trust_service.py
+++ b/server/core/trust_service.py
@@ -200,3 +200,21 @@ async def list_low_trust(
                     }
                 )
         return output
+
+    async def list_all_trust(self, limit: int = 1_000_000) -> list[dict]:
+        """Return every stored trust breakdown, best score first."""
+        rows = await self.db.list_all_trust(limit=limit)
+        output = []
+        for row in rows:
+            try:
+                output.append(json.loads(row["breakdown_json"]))
+            except Exception:
+                output.append(
+                    {
+                        "memory_id": row["memory_id"],
+                        "confidence": row["confidence"],
+                        "label": row["label"],
+                    }
+                )
+        output.sort(key=lambda b: b.get("confidence", 0), reverse=True)
+        return output
diff --git a/tests/test_full_export.py b/tests/test_full_export.py
new file mode 100644
index 0000000..cd27c86
--- /dev/null
+++ b/tests/test_full_export.py
@@ -0,0 +1,59 @@
+"""Tests for the full audit export (memories + entity graph + trust +
+conflicts) in JSON, SQLite, and PDF form. Offline & deterministic —
+EMBEDDER_MODE=hash."""
+
+import os
+import sys
+import tempfile
+
+import pytest
+import pytest_asyncio
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+os.environ["EMBEDDER_MODE"] = "hash"
+
+from server.core.full_export import build_full_export, export_full_sqlite, render_full_export_pdf
+from server.core.memory_engine import MemoryEngine
+
+
+@pytest_asyncio.fixture
+async def engine():
+    db_fd, db_path = tempfile.mkstemp(suffix=".db")
+    os.close(db_fd)
+    eng = MemoryEngine(db_path=db_path, embedder_mode="hash", short_term_max=10)
+    await eng.initialize()
+    yield eng
+    await eng.shutdown()
+    if os.path.exists(db_path):
+        os.unlink(db_path)
+
+
+@pytest.mark.asyncio
+async def test_build_full_export_counts(engine):
+    await engine.store("Met with attendees", memory_type="episodic", metadata={"attendees": ["a@x.com"]})
+    await engine.store("plain memory", memory_type="episodic")
+    await engine.recompute_trust_scores()
+
+    export = await build_full_export(engine)
+
+    assert export["format"] == "levh-full-export"
+    assert export["counts"]["memories"] == 2
+    assert export["counts"]["trust_scores"] == 2
+    assert len(export["memories"]) == 2
+    assert len(export["trust"]) == 2
+    assert "entity_stats" in export
+
+
+@pytest.mark.asyncio
+async def test_export_full_sqlite_is_valid_db(engine):
+    await engine.store("hello", memory_type="episodic")
+    blob = await export_full_sqlite(engine)
+    assert blob[:16] == b"SQLite format 3\x00"
+
+
+@pytest.mark.asyncio
+async def test_render_full_export_pdf_starts_with_pdf_header(engine):
+    await engine.store("hello", memory_type="episodic")
+    export = await build_full_export(engine)
+    blob = render_full_export_pdf(export)
+    assert blob[:5] == b"%PDF-"