diff --git a/ontology_platform/crawler_platform/app/api/routes.py b/ontology_platform/crawler_platform/app/api/routes.py
index 8b09b30..56e9e64 100644
--- a/ontology_platform/crawler_platform/app/api/routes.py
+++ b/ontology_platform/crawler_platform/app/api/routes.py
@@ -3,6 +3,7 @@ from __future__ import annotations
 import csv
 import io
 import json
+import re
 from dataclasses import asdict
 from typing import Any
 
@@ -28,7 +29,8 @@ from crawler_platform.app.core.database.repository import (
 from crawler_platform.app.core.database.session import session_scope
 from crawler_platform.app.core.extractor.ai_provider import list_openai_compatible_models
 from crawler_platform.app.core.extractor.factory import extractor_for_domain
-from crawler_platform.app.core.ontology.definitions import DOMAIN_ONTOLOGIES, ontology_for_domain
+from crawler_platform.app.core.ontology.definitions import DOMAIN_ONTOLOGIES, Ontology, ontology_for_domain
+from crawler_platform.app.core.ontology.domain_discovery import DomainDiscoveryService
 from crawler_platform.app.core.ontology.gap_detector import KnowledgeGapDetector
 from crawler_platform.app.core.ontology.mapper import ontology_to_dict
 from crawler_platform.app.core.ontology.registry import OntologyRegistry
@@ -38,6 +40,9 @@ from crawler_platform.app.core.research.graph_research_loop import GraphResearch
 from crawler_platform.app.core.research.memory_store import ResearchMemoryStore, research_session_payload
 
 
+DOMAIN_NAME_PATTERN = re.compile(r"^[a-z0-9][a-z0-9_-]{1,79}$")
+
+
 class CrawlRequest(BaseModel):
     config_path: str
     source_name: str
@@ -149,6 +154,41 @@ class CreateProjectInlineRequest(BaseModel):
         )
 
 
+class DomainDefinitionRequest(BaseModel):
+    domain: str
+    description: str | None = None
+    entity_types: list[str] = Field(default_factory=list)
+    predicates: list[str] = Field(default_factory=list)
+    attributes: list[str] = Field(default_factory=list)
+    aliases: dict[str, str] = Field(default_factory=dict)
+
+
+class DomainDefinitionUpdateRequest(BaseModel):
+    description: str | None = None
+    entity_types: list[str] = Field(default_factory=list)
+    predicates: list[str] = Field(default_factory=list)
+    attributes: list[str] = Field(default_factory=list)
+    aliases: dict[str, str] = Field(default_factory=dict)
+
+
+class DomainDiscoveryRequest(BaseModel):
+    seed_urls: list[str] = Field(default_factory=list)
+    max_pages: int = 20
+    max_depth: int = 1
+    same_domain_only: bool = True
+    fetcher: str = "requests"
+    respect_robots_txt: bool = False
+    force_recrawl: bool = False
+
+
+class DomainCandidateApplyRequest(BaseModel):
+    candidate_ids: list[int] = Field(default_factory=list)
+
+
+class DomainCandidateStatusRequest(BaseModel):
+    status: str
+
+
 class ResetProjectRequest(BaseModel):
     config_path: str
     project_name: str | None = None
@@ -165,6 +205,250 @@ def source_model_to_config(source: models.Source) -> SourceConfig:
     )
 
 
+def normalize_domain_name(domain: str) -> str:
+    normalized = domain.strip().lower()
+    if not DOMAIN_NAME_PATTERN.match(normalized):
+        raise HTTPException(
+            status_code=400,
+            detail="Domain must be 2-80 chars using lowercase letters, numbers, underscore, or hyphen.",
+        )
+    return normalized
+
+
+def clean_string_list(values: list[str]) -> list[str]:
+    cleaned: list[str] = []
+    seen: set[str] = set()
+    for value in values:
+        item = value.strip()
+        if not item or item in seen:
+            continue
+        cleaned.append(item)
+        seen.add(item)
+    return cleaned
+
+
+def clean_aliases(values: dict[str, str]) -> dict[str, str]:
+    return {
+        key.strip(): value.strip()
+        for key, value in values.items()
+        if key.strip() and value.strip()
+    }
+
+
+def domain_row_to_ontology(row: models.DomainDefinition):
+    return Ontology(
+        domain=row.domain,
+        entity_types=clean_string_list(list(row.entity_types or [])),
+        predicates=clean_string_list(list(row.predicates or [])),
+        attributes=clean_string_list(list(row.attributes or [])),
+        aliases=clean_aliases(dict(row.aliases or {})),
+    )
+
+
+def domain_summary_payload(ont, *, is_builtin: bool, is_custom: bool, description: str | None = None):
+    return {
+        "domain": ont.domain,
+        "description": description,
+        "entity_types": list(ont.entity_types),
+        "predicates": list(ont.predicates),
+        "attribute_count": len(ont.attributes),
+        "attributes": list(ont.attributes),
+        "aliases": dict(ont.aliases),
+        "is_builtin": is_builtin,
+        "is_custom": is_custom,
+    }
+
+
+def upsert_domain_definition(
+    session,
+    domain: str,
+    payload: DomainDefinitionUpdateRequest,
+) -> models.DomainDefinition:
+    normalized_domain = normalize_domain_name(domain)
+    row = session.scalar(
+        select(models.DomainDefinition).where(models.DomainDefinition.domain == normalized_domain)
+    )
+    if row is None:
+        row = models.DomainDefinition(domain=normalized_domain)
+        session.add(row)
+        session.flush()
+    row.description = payload.description.strip() if payload.description else None
+    row.entity_types = clean_string_list(payload.entity_types)
+    row.predicates = clean_string_list(payload.predicates)
+    row.attributes = clean_string_list(payload.attributes)
+    row.aliases = clean_aliases(payload.aliases)
+    row.is_builtin_override = normalized_domain in DOMAIN_ONTOLOGIES
+    row.updated_at = models.utcnow()
+    return row
+
+
+def ensure_domain_definition(session, domain: str) -> models.DomainDefinition:
+    normalized_domain = normalize_domain_name(domain)
+    row = session.scalar(
+        select(models.DomainDefinition).where(models.DomainDefinition.domain == normalized_domain)
+    )
+    if row is not None:
+        return row
+
+    base = DOMAIN_ONTOLOGIES.get(normalized_domain)
+    row = models.DomainDefinition(
+        domain=normalized_domain,
+        entity_types=list(base.entity_types) if base else [],
+        predicates=list(base.predicates) if base else [],
+        attributes=list(base.attributes) if base else [],
+        aliases=dict(base.aliases) if base else {},
+        is_builtin_override=normalized_domain in DOMAIN_ONTOLOGIES,
+    )
+    session.add(row)
+    session.flush()
+    return row
+
+
+def ontology_for_domain_from_db(session, domain: str):
+    normalized_domain = normalize_domain_name(domain)
+    row = session.scalar(
+        select(models.DomainDefinition).where(models.DomainDefinition.domain == normalized_domain)
+    )
+    if row is not None:
+        return domain_row_to_ontology(row)
+    return ontology_for_domain(normalized_domain)
+
+
+def clean_seed_urls(values: list[str]) -> list[str]:
+    cleaned: list[str] = []
+    seen: set[str] = set()
+    for value in values:
+        url = value.strip()
+        if not url or url in seen:
+            continue
+        if not (url.startswith("http://") or url.startswith("https://") or url.startswith("file://")):
+            raise HTTPException(status_code=400, detail=f"Unsupported URL: {url}")
+        cleaned.append(url)
+        seen.add(url)
+    if not cleaned:
+        raise HTTPException(status_code=400, detail="At least one reference URL is required.")
+    return cleaned
+
+
+def domain_discovery_job_payload(job: models.DomainDiscoveryJob) -> dict[str, Any]:
+    return {
+        "job_id": job.id,
+        "domain": job.domain,
+        "status": job.status,
+        "seed_urls": list(job.seed_urls or []),
+        "max_pages": job.max_pages,
+        "max_depth": job.max_depth,
+        "same_domain_only": job.same_domain_only,
+        "fetcher": job.fetcher,
+        "respect_robots_txt": job.respect_robots_txt,
+        "error": job.error,
+        "progress": job.progress or {},
+        "result_summary": job.result_summary or {},
+        "created_at": job.created_at.isoformat() if job.created_at else None,
+        "started_at": job.started_at.isoformat() if job.started_at else None,
+        "finished_at": job.finished_at.isoformat() if job.finished_at else None,
+    }
+
+
+def domain_reference_source_payload(row: models.DomainReferenceSource) -> dict[str, Any]:
+    return {
+        "id": row.id,
+        "domain": row.domain,
+        "url": row.url,
+        "label": row.label,
+        "status": row.status,
+        "last_crawled_at": row.last_crawled_at.isoformat() if row.last_crawled_at else None,
+        "metadata": row.metadata_json or {},
+        "created_at": row.created_at.isoformat() if row.created_at else None,
+        "updated_at": row.updated_at.isoformat() if row.updated_at else None,
+    }
+
+
+def already_crawled_reference_urls(session, domain: str, seed_urls: list[str]) -> set[str]:
+    if not seed_urls:
+        return set()
+    rows = session.scalars(
+        select(models.DomainReferenceSource).where(
+            models.DomainReferenceSource.domain == domain,
+            models.DomainReferenceSource.url.in_(seed_urls),
+            models.DomainReferenceSource.status == "active",
+            models.DomainReferenceSource.last_crawled_at.is_not(None),
+        )
+    ).all()
+    return {row.url for row in rows}
+
+
+def domain_candidate_payload(row: models.DomainSchemaCandidate, evidence_rows: list[models.DomainCandidateEvidence]) -> dict[str, Any]:
+    return {
+        "id": row.id,
+        "domain": row.domain,
+        "job_id": row.job_id,
+        "candidate_type": row.candidate_type,
+        "name": row.name,
+        "description": row.description,
+        "confidence": row.confidence,
+        "occurrence_count": row.occurrence_count,
+        "status": row.status,
+        "metadata": row.metadata_json or {},
+        "created_at": row.created_at.isoformat() if row.created_at else None,
+        "updated_at": row.updated_at.isoformat() if row.updated_at else None,
+        "evidence": [
+            {
+                "id": evidence.id,
+                "job_id": evidence.job_id,
+                "url": evidence.url,
+                "title": evidence.title,
+                "snippet": evidence.snippet,
+                "metadata": evidence.metadata_json or {},
+                "created_at": evidence.created_at.isoformat() if evidence.created_at else None,
+            }
+            for evidence in evidence_rows
+        ],
+    }
+
+
+def run_domain_discovery_job(database_url: str, job_id: int) -> None:
+    try:
+        with session_scope(database_url) as session:
+            DomainDiscoveryService(session).run_job(job_id)
+    except Exception as exc:
+        with session_scope(database_url) as session:
+            job = session.get(models.DomainDiscoveryJob, job_id)
+            if job is not None:
+                job.status = "failed"
+                job.error = str(exc)
+                job.finished_at = models.utcnow()
+                progress = dict(job.progress or {})
+                progress["errors"] = [*progress.get("errors", []), str(exc)]
+                job.progress = progress
+
+
+def recover_interrupted_domain_discovery_jobs(database_url: str) -> None:
+    """Mark domain discovery jobs that cannot survive a server restart."""
+    with session_scope(database_url) as session:
+        rows = session.scalars(
+            select(models.DomainDiscoveryJob).where(
+                models.DomainDiscoveryJob.status.in_(
+                    ["pending", "running", "cancel_requested"]
+                )
+            )
+        ).all()
+        for job in rows:
+            progress = dict(job.progress or {})
+            errors = list(progress.get("errors") or [])
+            if job.status == "cancel_requested":
+                job.status = "canceled"
+                progress["completion_reason"] = "canceled"
+            else:
+                job.status = "failed"
+                job.error = "Server restarted before this background analysis finished."
+                progress["completion_reason"] = "interrupted"
+                errors.append(job.error)
+            progress["errors"] = errors[-10:]
+            job.progress = progress
+            job.finished_at = models.utcnow()
+
+
 def project_config_from_project_row(session, project: models.Project) -> ProjectConfig:
     config_dict = dict(project.config or {})
     if not config_dict:
@@ -195,6 +479,32 @@ def project_config_to_dict(config: ProjectConfig) -> dict[str, Any]:
     }
 
 
+def delete_project_data(session, project_id: int, include_project: bool = False) -> dict[str, int]:
+    repo = KnowledgeRepository(session)
+    deleted = repo.reset_project_runtime_data(project_id)
+    for table_model in [
+        models.OntologyProposal,
+        models.OntologyTriple,
+        models.OntologyRelationType,
+        models.OntologyEntityType,
+        models.Source,
+    ]:
+        count = (
+            session.query(table_model)
+            .filter(table_model.project_id == project_id)
+            .delete(synchronize_session=False)
+        )
+        deleted[table_model.__tablename__] = deleted.get(table_model.__tablename__, 0) + int(count or 0)
+    if include_project:
+        project_count = (
+            session.query(models.Project)
+            .filter(models.Project.id == project_id)
+            .delete(synchronize_session=False)
+        )
+        deleted[models.Project.__tablename__] = int(project_count or 0)
+    return deleted
+
+
 class CreateEntityRequest(BaseModel):
     entity_type: str
     name: str
@@ -485,6 +795,8 @@ def run_site_crawl_job(database_url: str, job_id: int, request_data: dict[str, A
 
 
 def register_routes(app, database_url: str) -> None:
+    recover_interrupted_domain_discovery_jobs(database_url)
+
     @app.get("/health")
     def health():
         return {"ok": True}
@@ -520,16 +832,298 @@ def register_routes(app, database_url: str) -> None:
 
     @app.get("/domains")
     def list_domains():
-        """Available pre-defined ontology domains for project creation."""
-        return [
-            {
-                "domain": ont.domain,
-                "entity_types": list(ont.entity_types),
-                "predicates": list(ont.predicates),
-                "attribute_count": len(ont.attributes),
+        """Available ontology domains for project creation."""
+        with session_scope(database_url) as session:
+            rows = session.scalars(select(models.DomainDefinition)).all()
+            custom_by_domain = {row.domain: row for row in rows}
+            payloads = []
+            for domain, built_in in DOMAIN_ONTOLOGIES.items():
+                row = custom_by_domain.pop(domain, None)
+                if row is not None:
+                    payloads.append(
+                        domain_summary_payload(
+                            domain_row_to_ontology(row),
+                            is_builtin=True,
+                            is_custom=True,
+                            description=row.description,
+                        )
+                    )
+                else:
+                    payloads.append(
+                        domain_summary_payload(
+                            built_in,
+                            is_builtin=True,
+                            is_custom=False,
+                        )
+                    )
+            for row in sorted(custom_by_domain.values(), key=lambda item: item.domain):
+                payloads.append(
+                    domain_summary_payload(
+                        domain_row_to_ontology(row),
+                        is_builtin=False,
+                        is_custom=True,
+                        description=row.description,
+                    )
+                )
+            return payloads
+
+    @app.post("/domains")
+    def create_domain(request: DomainDefinitionRequest):
+        domain = normalize_domain_name(request.domain)
+        with session_scope(database_url) as session:
+            existing = session.scalar(
+                select(models.DomainDefinition).where(models.DomainDefinition.domain == domain)
+            )
+            if existing is not None or domain in DOMAIN_ONTOLOGIES:
+                raise HTTPException(status_code=409, detail=f"Domain '{domain}' already exists.")
+            row = upsert_domain_definition(
+                session,
+                domain,
+                DomainDefinitionUpdateRequest(
+                    description=request.description,
+                    entity_types=request.entity_types,
+                    predicates=request.predicates,
+                    attributes=request.attributes,
+                    aliases=request.aliases,
+                ),
+            )
+            return domain_summary_payload(
+                domain_row_to_ontology(row),
+                is_builtin=domain in DOMAIN_ONTOLOGIES,
+                is_custom=True,
+                description=row.description,
+            )
+
+    @app.put("/domains/{domain}")
+    def update_domain(domain: str, request: DomainDefinitionUpdateRequest):
+        with session_scope(database_url) as session:
+            row = upsert_domain_definition(session, domain, request)
+            return domain_summary_payload(
+                domain_row_to_ontology(row),
+                is_builtin=row.domain in DOMAIN_ONTOLOGIES,
+                is_custom=True,
+                description=row.description,
+            )
+
+    @app.get("/domains/{domain}/discovery/jobs")
+    def list_domain_discovery_jobs(domain: str, limit: int = 20):
+        normalized_domain = normalize_domain_name(domain)
+        with session_scope(database_url) as session:
+            rows = session.scalars(
+                select(models.DomainDiscoveryJob)
+                .where(models.DomainDiscoveryJob.domain == normalized_domain)
+                .order_by(models.DomainDiscoveryJob.created_at.desc())
+                .limit(max(min(limit, 100), 1))
+            ).all()
+            return [domain_discovery_job_payload(row) for row in rows]
+
+    @app.get("/domains/{domain}/reference-sources")
+    def list_domain_reference_sources(domain: str):
+        normalized_domain = normalize_domain_name(domain)
+        with session_scope(database_url) as session:
+            rows = session.scalars(
+                select(models.DomainReferenceSource)
+                .where(models.DomainReferenceSource.domain == normalized_domain)
+                .order_by(models.DomainReferenceSource.updated_at.desc())
+            ).all()
+            return [domain_reference_source_payload(row) for row in rows]
+
+    @app.post("/domains/{domain}/discovery/jobs")
+    def create_domain_discovery_job(
+        domain: str,
+        request: DomainDiscoveryRequest,
+        background_tasks: BackgroundTasks,
+    ):
+        normalized_domain = normalize_domain_name(domain)
+        seed_urls = clean_seed_urls(request.seed_urls)
+        with session_scope(database_url) as session:
+            ensure_domain_definition(session, normalized_domain)
+            skipped_seed_urls: list[str] = []
+            if not request.force_recrawl:
+                skipped = already_crawled_reference_urls(session, normalized_domain, seed_urls)
+                skipped_seed_urls = [url for url in seed_urls if url in skipped]
+                seed_urls = [url for url in seed_urls if url not in skipped]
+
+            if not seed_urls:
+                job = models.DomainDiscoveryJob(
+                    domain=normalized_domain,
+                    status="completed",
+                    seed_urls=[],
+                    max_pages=max(min(request.max_pages, 200), 1),
+                    max_depth=max(min(request.max_depth, 5), 0),
+                    same_domain_only=request.same_domain_only,
+                    fetcher=request.fetcher if request.fetcher in {"requests", "playwright", "browser"} else "requests",
+                    respect_robots_txt=request.respect_robots_txt,
+                    progress={
+                        "visited_count": 0,
+                        "queued_count": 0,
+                        "candidate_count": 0,
+                        "observation_count": 0,
+                        "max_pages": max(min(request.max_pages, 200), 1),
+                        "skipped_seed_urls": skipped_seed_urls,
+                        "errors": [],
+                        "pages": [],
+                    },
+                    result_summary={
+                        "visited_count": 0,
+                        "candidate_count": 0,
+                        "skipped_seed_urls": skipped_seed_urls,
+                    },
+                    finished_at=models.utcnow(),
+                )
+                session.add(job)
+                session.flush()
+                return domain_discovery_job_payload(job)
+
+            job = models.DomainDiscoveryJob(
+                domain=normalized_domain,
+                status="pending",
+                seed_urls=seed_urls,
+                max_pages=max(min(request.max_pages, 200), 1),
+                max_depth=max(min(request.max_depth, 5), 0),
+                same_domain_only=request.same_domain_only,
+                fetcher=request.fetcher if request.fetcher in {"requests", "playwright", "browser"} else "requests",
+                respect_robots_txt=request.respect_robots_txt,
+                progress={
+                    "visited_count": 0,
+                    "queued_count": len(seed_urls),
+                    "candidate_count": 0,
+                    "observation_count": 0,
+                    "max_pages": max(min(request.max_pages, 200), 1),
+                    "skipped_seed_urls": skipped_seed_urls,
+                    "errors": [],
+                    "pages": [],
+                },
+            )
+            session.add(job)
+            session.flush()
+            response = domain_discovery_job_payload(job)
+        background_tasks.add_task(run_domain_discovery_job, database_url, response["job_id"])
+        return response
+
+    @app.get("/domains/{domain}/discovery/jobs/{job_id}")
+    def domain_discovery_job(domain: str, job_id: int):
+        normalized_domain = normalize_domain_name(domain)
+        with session_scope(database_url) as session:
+            job = session.get(models.DomainDiscoveryJob, job_id)
+            if job is None or job.domain != normalized_domain:
+                raise HTTPException(status_code=404, detail="domain discovery job not found")
+            return domain_discovery_job_payload(job)
+
+    @app.post("/domains/{domain}/discovery/jobs/{job_id}/cancel")
+    def cancel_domain_discovery_job(domain: str, job_id: int):
+        normalized_domain = normalize_domain_name(domain)
+        with session_scope(database_url) as session:
+            job = session.get(models.DomainDiscoveryJob, job_id)
+            if job is None or job.domain != normalized_domain:
+                raise HTTPException(status_code=404, detail="domain discovery job not found")
+            if job.status in {"completed", "failed", "canceled"}:
+                return domain_discovery_job_payload(job)
+            job.status = "cancel_requested"
+            job.error = "cancel requested by user"
+            return domain_discovery_job_payload(job)
+
+    @app.get("/domains/{domain}/candidates")
+    def list_domain_candidates(domain: str, status: str | None = None, limit: int = 200):
+        normalized_domain = normalize_domain_name(domain)
+        with session_scope(database_url) as session:
+            query = select(models.DomainSchemaCandidate).where(
+                models.DomainSchemaCandidate.domain == normalized_domain
+            )
+            if status:
+                query = query.where(models.DomainSchemaCandidate.status == status)
+            rows = session.scalars(
+                query.order_by(
+                    models.DomainSchemaCandidate.status,
+                    models.DomainSchemaCandidate.candidate_type,
+                    models.DomainSchemaCandidate.confidence.desc(),
+                    models.DomainSchemaCandidate.name,
+                ).limit(max(min(limit, 500), 1))
+            ).all()
+            payload = []
+            for row in rows:
+                evidence = session.scalars(
+                    select(models.DomainCandidateEvidence)
+                    .where(models.DomainCandidateEvidence.candidate_id == row.id)
+                    .order_by(models.DomainCandidateEvidence.created_at.desc())
+                    .limit(3)
+                ).all()
+                payload.append(domain_candidate_payload(row, evidence))
+            return payload
+
+    @app.post("/domains/{domain}/candidates/apply")
+    def apply_domain_candidates(domain: str, request: DomainCandidateApplyRequest):
+        normalized_domain = normalize_domain_name(domain)
+        if not request.candidate_ids:
+            raise HTTPException(status_code=400, detail="No candidates selected.")
+        with session_scope(database_url) as session:
+            definition = ensure_domain_definition(session, normalized_domain)
+            rows = session.scalars(
+                select(models.DomainSchemaCandidate).where(
+                    models.DomainSchemaCandidate.domain == normalized_domain,
+                    models.DomainSchemaCandidate.id.in_(request.candidate_ids),
+                )
+            ).all()
+            entity_types = set(definition.entity_types or [])
+            predicates = set(definition.predicates or [])
+            attributes = set(definition.attributes or [])
+            aliases = dict(definition.aliases or {})
+            applied = {"entity_type": 0, "predicate": 0, "attribute": 0, "alias": 0}
+            for row in rows:
+                if row.candidate_type == "entity_type":
+                    entity_types.add(row.name)
+                    applied["entity_type"] += 1
+                elif row.candidate_type == "predicate":
+                    predicates.add(row.name)
+                    applied["predicate"] += 1
+                elif row.candidate_type == "attribute":
+                    attributes.add(row.name)
+                    applied["attribute"] += 1
+                elif row.candidate_type == "alias":
+                    metadata = dict(row.metadata_json or {})
+                    targets = metadata.get("targets") or []
+                    target = metadata.get("target") or (targets[0] if targets else None)
+                    if target:
+                        aliases[row.name] = str(target)
+                        applied["alias"] += 1
+                row.status = "approved"
+                row.updated_at = models.utcnow()
+            definition.entity_types = sorted(entity_types)
+            definition.predicates = sorted(predicates)
+            definition.attributes = sorted(attributes)
+            definition.aliases = aliases
+            definition.is_builtin_override = normalized_domain in DOMAIN_ONTOLOGIES
+            definition.updated_at = models.utcnow()
+            return {
+                "ok": True,
+                "domain": normalized_domain,
+                "applied": applied,
+                "definition": domain_summary_payload(
+                    domain_row_to_ontology(definition),
+                    is_builtin=normalized_domain in DOMAIN_ONTOLOGIES,
+                    is_custom=True,
+                    description=definition.description,
+                ),
             }
-            for ont in DOMAIN_ONTOLOGIES.values()
-        ]
+
+    @app.post("/domains/{domain}/candidates/{candidate_id}/status")
+    def update_domain_candidate_status(domain: str, candidate_id: int, request: DomainCandidateStatusRequest):
+        normalized_domain = normalize_domain_name(domain)
+        if request.status not in {"pending_review", "approved", "rejected"}:
+            raise HTTPException(status_code=400, detail="Unsupported candidate status.")
+        with session_scope(database_url) as session:
+            row = session.get(models.DomainSchemaCandidate, candidate_id)
+            if row is None or row.domain != normalized_domain:
+                raise HTTPException(status_code=404, detail="candidate not found")
+            row.status = request.status
+            row.updated_at = models.utcnow()
+            evidence = session.scalars(
+                select(models.DomainCandidateEvidence)
+                .where(models.DomainCandidateEvidence.candidate_id == row.id)
+                .order_by(models.DomainCandidateEvidence.created_at.desc())
+                .limit(3)
+            ).all()
+            return domain_candidate_payload(row, evidence)
 
     @app.post("/projects/reset")
     def reset_project(request: ResetProjectRequest):
@@ -568,6 +1162,35 @@ def register_routes(app, database_url: str) -> None:
                 "deleted": deleted,
             }
 
+    @app.post("/projects/{project_name}/reset")
+    def reset_project_by_name(project_name: str):
+        with session_scope(database_url) as session:
+            repo = KnowledgeRepository(session)
+            project = repo.get_project(project_name)
+            config = project_config_from_project_row(session, project)
+            deleted = repo.reset_project_runtime_data(project.id)
+            project = repo.upsert_project(config)
+            return {
+                "ok": True,
+                "name": project.name,
+                "domain": project.domain,
+                "reset": True,
+                "deleted": deleted,
+            }
+
+    @app.delete("/projects/{project_name}")
+    def delete_project(project_name: str):
+        with session_scope(database_url) as session:
+            project = KnowledgeRepository(session).get_project(project_name)
+            domain = project.domain
+            deleted = delete_project_data(session, project.id, include_project=True)
+            return {
+                "ok": True,
+                "name": project_name,
+                "domain": domain,
+                "deleted": deleted,
+            }
+
     @app.get("/projects/{project_name}")
     def project_detail(project_name: str):
         with session_scope(database_url) as session:
@@ -630,7 +1253,8 @@ def register_routes(app, database_url: str) -> None:
 
     @app.get("/ontology/{domain}")
     def ontology(domain: str):
-        return ontology_to_dict(ontology_for_domain(domain))
+        with session_scope(database_url) as session:
+            return ontology_to_dict(ontology_for_domain_from_db(session, domain))
 
     @app.get("/projects/{project_name}/ontology/registry")
     def ontology_registry(project_name: str):
diff --git a/ontology_platform/crawler_platform/app/core/database/models.py b/ontology_platform/crawler_platform/app/core/database/models.py
index 5d35f96..dbd314b 100644
--- a/ontology_platform/crawler_platform/app/core/database/models.py
+++ b/ontology_platform/crawler_platform/app/core/database/models.py
@@ -56,6 +56,91 @@ class Source(Base):
     project = relationship("Project", back_populates="sources")
 
 
+class DomainDefinition(Base):
+    __tablename__ = "domain_definitions"
+
+    id = Column(Integer, primary_key=True)
+    domain = Column(String(80), unique=True, nullable=False, index=True)
+    description = Column(Text)
+    entity_types = Column(JSON, nullable=False, default=list)
+    predicates = Column(JSON, nullable=False, default=list)
+    attributes = Column(JSON, nullable=False, default=list)
+    aliases = Column(JSON, nullable=False, default=dict)
+    is_builtin_override = Column(Boolean, nullable=False, default=False)
+    created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+    updated_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+
+
+class DomainReferenceSource(Base):
+    __tablename__ = "domain_reference_sources"
+    __table_args__ = (
+        UniqueConstraint("domain", "url", name="uq_domain_reference_source"),
+    )
+
+    id = Column(Integer, primary_key=True)
+    domain = Column(String(80), nullable=False, index=True)
+    url = Column(Text, nullable=False)
+    label = Column(String(160))
+    status = Column(String(40), nullable=False, default="active", index=True)
+    last_crawled_at = Column(DateTime(timezone=True), nullable=True)
+    metadata_json = Column(JSON, nullable=False, default=dict)
+    created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+    updated_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+
+
+class DomainDiscoveryJob(Base):
+    __tablename__ = "domain_discovery_jobs"
+
+    id = Column(Integer, primary_key=True)
+    domain = Column(String(80), nullable=False, index=True)
+    status = Column(String(40), nullable=False, default="pending", index=True)
+    seed_urls = Column(JSON, nullable=False, default=list)
+    max_pages = Column(Integer, nullable=False, default=20)
+    max_depth = Column(Integer, nullable=False, default=1)
+    same_domain_only = Column(Boolean, nullable=False, default=True)
+    fetcher = Column(String(80), nullable=False, default="requests")
+    respect_robots_txt = Column(Boolean, nullable=False, default=False)
+    error = Column(Text)
+    progress = Column(JSON, nullable=False, default=dict)
+    result_summary = Column(JSON, nullable=False, default=dict)
+    created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+    started_at = Column(DateTime(timezone=True), nullable=True)
+    finished_at = Column(DateTime(timezone=True), nullable=True)
+
+
+class DomainSchemaCandidate(Base):
+    __tablename__ = "domain_schema_candidates"
+    __table_args__ = (
+        UniqueConstraint("domain", "candidate_type", "name", name="uq_domain_schema_candidate"),
+    )
+
+    id = Column(Integer, primary_key=True)
+    domain = Column(String(80), nullable=False, index=True)
+    job_id = Column(Integer, ForeignKey("domain_discovery_jobs.id"), nullable=True, index=True)
+    candidate_type = Column(String(40), nullable=False, index=True)
+    name = Column(String(160), nullable=False, index=True)
+    description = Column(Text)
+    confidence = Column(Float, nullable=False, default=0.5)
+    occurrence_count = Column(Integer, nullable=False, default=1)
+    status = Column(String(40), nullable=False, default="pending_review", index=True)
+    metadata_json = Column(JSON, nullable=False, default=dict)
+    created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+    updated_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+
+
+class DomainCandidateEvidence(Base):
+    __tablename__ = "domain_candidate_evidence"
+
+    id = Column(Integer, primary_key=True)
+    candidate_id = Column(Integer, ForeignKey("domain_schema_candidates.id"), nullable=False, index=True)
+    job_id = Column(Integer, ForeignKey("domain_discovery_jobs.id"), nullable=True, index=True)
+    url = Column(Text, nullable=False)
+    title = Column(Text)
+    snippet = Column(Text, nullable=False)
+    metadata_json = Column(JSON, nullable=False, default=dict)
+    created_at = Column(DateTime(timezone=True), default=utcnow, nullable=False)
+
+
 class Page(Base):
     __tablename__ = "pages"
     __table_args__ = (UniqueConstraint("project_id", "url", name="uq_page_project_url"),)
diff --git a/ontology_platform/crawler_platform/app/core/ontology/domain_discovery.py b/ontology_platform/crawler_platform/app/core/ontology/domain_discovery.py
new file mode 100644
index 0000000..dfd96a8
--- /dev/null
+++ b/ontology_platform/crawler_platform/app/core/ontology/domain_discovery.py
@@ -0,0 +1,643 @@
+from __future__ import annotations
+
+from collections import Counter, deque
+from dataclasses import dataclass, field
+import json
+import re
+from typing import Any
+from urllib.parse import urlparse
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from crawler_platform.app.core.crawler.discovery import discover_links
+from crawler_platform.app.core.crawler.fetchers import RobotsPolicy, make_fetcher
+from crawler_platform.app.core.crawler.page_classifier import classify_page
+from crawler_platform.app.core.crawler.plugins import default_parser_registry
+from crawler_platform.app.core.database import models
+
+
+SCHEMA_TYPES = {"entity_type", "predicate", "attribute", "alias"}
+RELATION_HINTS = {
+    "brand": ("Brand", "hasBrand"),
+    "브랜드": ("Brand", "hasBrand"),
+    "category": ("Category", "hasCategory"),
+    "카테고리": ("Category", "hasCategory"),
+    "ingredient": ("Ingredient", "hasIngredient"),
+    "ingredients": ("Ingredient", "hasIngredient"),
+    "성분": ("Ingredient", "hasIngredient"),
+    "effect": ("Effect", "hasEffect"),
+    "benefit": ("Effect", "hasEffect"),
+    "효과": ("Effect", "hasEffect"),
+    "효능": ("Effect", "hasEffect"),
+    "warning": ("Warning", "hasWarning"),
+    "주의": ("Warning", "hasWarning"),
+    "review": ("Review", "hasReview"),
+    "rating": ("Rating", "hasRating"),
+    "image": ("Image", "hasImage"),
+    "price": ("Price", "hasPrice"),
+    "가격": ("Price", "hasPrice"),
+    "offer": ("Offer", "hasOffer"),
+}
+
+
+@dataclass(slots=True)
+class CandidateEvidence:
+    url: str
+    title: str | None
+    snippet: str
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class CandidateObservation:
+    candidate_type: str
+    name: str
+    description: str
+    confidence: float
+    evidence: CandidateEvidence
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+class DomainDiscoveryService:
+    def __init__(self, session: Session):
+        self.session = session
+        self.parser = default_parser_registry().get("generic")
+
+    def run_job(self, job_id: int) -> None:
+        job = self.session.get(models.DomainDiscoveryJob, job_id)
+        if job is None:
+            return
+
+        job.status = "running"
+        job.started_at = models.utcnow()
+        job.progress = {
+            "visited_count": 0,
+            "queued_count": len(job.seed_urls or []),
+            "candidate_count": 0,
+            "errors": [],
+            "pages": [],
+        }
+        self.session.commit()
+
+        visited: set[str] = set()
+        queued: set[str] = set()
+        queue: deque[tuple[str, int, str]] = deque()
+        for seed_url in job.seed_urls or []:
+            normalized = normalize_url(str(seed_url))
+            if normalized:
+                queue.append((normalized, 0, seed_host(normalized)))
+                queued.add(normalized)
+                self._upsert_reference_source(job.domain, normalized)
+
+        fetcher = make_fetcher(job.fetcher, rate_limit_per_minute=30)
+        robots = RobotsPolicy()
+        observation_count = 0
+        errors: list[str] = []
+        page_payloads: list[dict[str, Any]] = []
+
+        while queue and len(visited) < max(min(job.max_pages, 200), 1):
+            if self._cancel_requested(job):
+                job.status = "canceled"
+                job.finished_at = models.utcnow()
+                self.session.commit()
+                return
+
+            url, depth, root_host = queue.popleft()
+            if url in visited:
+                continue
+            visited.add(url)
+
+            if depth > max(job.max_depth, 0):
+                continue
+            if job.same_domain_only and seed_host(url) != root_host:
+                continue
+
+            decision = robots.check(url, job.respect_robots_txt)
+            if not decision.allowed:
+                errors.append(f"{decision.reason}: {url}")
+                self._save_progress(job, visited, queue, observation_count, errors, page_payloads)
+                continue
+
+            try:
+                fetched = fetcher.fetch(url)
+                parsed = self.parser.parse(fetched.analysis_html, fetched.final_url or url)
+                page_type = classify_page(
+                    fetched.final_url or url,
+                    parsed.title or fetched.title,
+                    parsed.text or parsed.raw_text,
+                    html=fetched.analysis_html,
+                    source_zones=parsed.source_zones or [],
+                )
+                page_observations = mine_schema_candidates(
+                    url=fetched.final_url or url,
+                    title=parsed.title or fetched.title,
+                    text=parsed.text or parsed.raw_text,
+                    html=fetched.analysis_html,
+                    page_type=page_type,
+                )
+                observation_count += len(page_observations)
+                if page_observations:
+                    self._save_observations(job, page_observations)
+                page_payloads.append(
+                    {
+                        "url": fetched.final_url or url,
+                        "title": parsed.title or fetched.title,
+                        "page_type": page_type,
+                        "candidate_count": len(page_observations),
+                        "text_length": len(parsed.text or ""),
+                        "warnings": [*fetched.warnings, *(parsed.extraction_warnings or [])],
+                    }
+                )
+                self._enqueue_links(
+                    html=fetched.analysis_html,
+                    base_url=fetched.final_url or url,
+                    root_host=root_host,
+                    depth=depth,
+                    max_depth=max(job.max_depth, 0),
+                    same_domain_only=job.same_domain_only,
+                    queue=queue,
+                    queued=queued,
+                    visited=visited,
+                )
+            except Exception as exc:
+                errors.append(f"{url}: {exc}")
+
+            self._save_progress(job, visited, queue, observation_count, errors, page_payloads)
+
+        reached_page_limit = len(visited) >= max(min(job.max_pages, 200), 1)
+        completion_reason = "max_pages_reached" if reached_page_limit else "no_more_links"
+        saved = self._candidate_count(job.domain)
+        job.status = "completed"
+        job.finished_at = models.utcnow()
+        job.result_summary = {
+            "visited_count": len(visited),
+            "candidate_count": saved,
+            "completion_reason": completion_reason,
+            "errors": errors[-20:],
+            "pages": page_payloads[-50:],
+        }
+        self._save_progress(
+            job,
+            visited,
+            queue,
+            observation_count,
+            errors,
+            page_payloads,
+            completion_reason=completion_reason,
+        )
+        self.session.commit()
+
+    def _save_progress(
+        self,
+        job: models.DomainDiscoveryJob,
+        visited: set[str],
+        queue: deque[tuple[str, int, str]],
+        observation_count: int,
+        errors: list[str],
+        page_payloads: list[dict[str, Any]],
+        completion_reason: str | None = None,
+    ) -> None:
+        job.progress = {
+            "visited_count": len(visited),
+            "queued_count": len(queue),
+            "candidate_count": self._candidate_count(job.domain),
+            "observation_count": observation_count,
+            "max_pages": job.max_pages,
+            "errors": errors[-10:],
+            "pages": page_payloads[-10:],
+        }
+        if completion_reason:
+            job.progress["completion_reason"] = completion_reason
+        self.session.commit()
+
+    def _cancel_requested(self, job: models.DomainDiscoveryJob) -> bool:
+        self.session.expire(job)
+        return job.status == "cancel_requested"
+
+    def _candidate_count(self, domain: str) -> int:
+        return int(
+            self.session.query(models.DomainSchemaCandidate)
+            .filter(models.DomainSchemaCandidate.domain == domain)
+            .count()
+        )
+
+    def _save_observations(self, job: models.DomainDiscoveryJob, observations: list[CandidateObservation]) -> int:
+        if not observations:
+            return 0
+
+        by_key: dict[tuple[str, str], list[CandidateObservation]] = {}
+        for observation in observations:
+            if observation.candidate_type not in SCHEMA_TYPES:
+                continue
+            key = (observation.candidate_type, observation.name)
+            by_key.setdefault(key, []).append(observation)
+
+        saved_count = 0
+        for (candidate_type, name), rows in sorted(by_key.items()):
+            row = self.session.scalar(
+                select(models.DomainSchemaCandidate).where(
+                    models.DomainSchemaCandidate.domain == job.domain,
+                    models.DomainSchemaCandidate.candidate_type == candidate_type,
+                    models.DomainSchemaCandidate.name == name,
+                )
+            )
+            confidence = min(max(max(item.confidence for item in rows) + min(len(rows), 10) * 0.02, 0.0), 0.98)
+            metadata = merge_metadata(item.metadata for item in rows)
+            if row is None:
+                row = models.DomainSchemaCandidate(
+                    domain=job.domain,
+                    job_id=job.id,
+                    candidate_type=candidate_type,
+                    name=name,
+                    description=rows[0].description,
+                    confidence=round(confidence, 4),
+                    occurrence_count=len(rows),
+                    metadata_json=metadata,
+                )
+                self.session.add(row)
+                self.session.flush()
+            else:
+                row.job_id = job.id
+                row.description = row.description or rows[0].description
+                row.confidence = max(row.confidence, round(confidence, 4))
+                row.occurrence_count += len(rows)
+                row.metadata_json = {**(row.metadata_json or {}), **metadata}
+                row.updated_at = models.utcnow()
+            for evidence in rows[:8]:
+                self.session.add(
+                    models.DomainCandidateEvidence(
+                        candidate_id=row.id,
+                        job_id=job.id,
+                        url=evidence.evidence.url,
+                        title=evidence.evidence.title,
+                        snippet=evidence.evidence.snippet[:1000],
+                        metadata_json=evidence.evidence.metadata,
+                    )
+                )
+            saved_count += 1
+        return saved_count
+
+    def _upsert_reference_source(self, domain: str, url: str) -> models.DomainReferenceSource:
+        row = self.session.scalar(
+            select(models.DomainReferenceSource).where(
+                models.DomainReferenceSource.domain == domain,
+                models.DomainReferenceSource.url == url,
+            )
+        )
+        if row is None:
+            row = models.DomainReferenceSource(domain=domain, url=url)
+            self.session.add(row)
+            self.session.flush()
+        row.last_crawled_at = models.utcnow()
+        row.updated_at = models.utcnow()
+        return row
+
+    def _enqueue_links(
+        self,
+        *,
+        html: str,
+        base_url: str,
+        root_host: str,
+        depth: int,
+        max_depth: int,
+        same_domain_only: bool,
+        queue: deque[tuple[str, int, str]],
+        queued: set[str],
+        visited: set[str],
+    ) -> None:
+        if depth >= max_depth:
+            return
+        for link in discover_links(html, base_url, limit=100):
+            next_url = normalize_url(link.url)
+            if not next_url or next_url in queued or next_url in visited:
+                continue
+            if same_domain_only and seed_host(next_url) != root_host:
+                continue
+            queue.append((next_url, depth + 1, root_host))
+            queued.add(next_url)
+
+
+def mine_schema_candidates(
+    *,
+    url: str,
+    title: str | None,
+    text: str,
+    html: str,
+    page_type: str,
+) -> list[CandidateObservation]:
+    observations: list[CandidateObservation] = []
+    evidence_base = {"page_type": page_type}
+    page_type_entity = entity_type_from_page_type(page_type)
+    if page_type_entity:
+        observations.append(
+            observation(
+                "entity_type",
+                page_type_entity,
+                f"Detected from page type {page_type}.",
+                0.72,
+                url,
+                title,
+                title or first_sentence(text),
+                evidence_base,
+            )
+        )
+
+    soup = soup_from_html(html)
+    labels = collect_structural_labels(soup, text)
+    json_ld_types, json_ld_keys = collect_json_ld_schema(soup)
+
+    for schema_type, count in json_ld_types.items():
+        observations.append(
+            observation(
+                "entity_type",
+                pascal_case(schema_type),
+                "Detected from JSON-LD schema type.",
+                min(0.86 + count * 0.02, 0.95),
+                url,
+                title,
+                f"JSON-LD @type: {schema_type}",
+                {**evidence_base, "source": "json_ld"},
+            )
+        )
+    for key, count in json_ld_keys.items():
+        attr = attribute_name(key)
+        if attr:
+            observations.append(
+                observation(
+                    "attribute",
+                    attr,
+                    "Detected from structured data property.",
+                    min(0.78 + count * 0.02, 0.92),
+                    url,
+                    title,
+                    f"Structured data property: {key}",
+                    {**evidence_base, "source": "json_ld", "raw_label": key},
+                )
+            )
+
+    for label, count in labels.items():
+        attr = attribute_name(label)
+        if not attr:
+            continue
+        observations.append(
+            observation(
+                "attribute",
+                attr,
+                "Detected from page labels, tables, metadata, or key-value text.",
+                min(0.62 + count * 0.04, 0.88),
+                url,
+                title,
+                label,
+                {**evidence_base, "source": "page_label", "raw_label": label},
+            )
+        )
+        hint = relation_hint(label)
+        if hint:
+            entity_type, predicate = hint
+            observations.append(
+                observation(
+                    "entity_type",
+                    entity_type,
+                    f"Detected from repeated label '{label}'.",
+                    min(0.68 + count * 0.03, 0.9),
+                    url,
+                    title,
+                    label,
+                    {**evidence_base, "source": "relation_hint", "raw_label": label},
+                )
+            )
+            observations.append(
+                observation(
+                    "predicate",
+                    predicate,
+                    f"Suggested relation for label '{label}'.",
+                    min(0.7 + count * 0.03, 0.92),
+                    url,
+                    title,
+                    label,
+                    {
+                        **evidence_base,
+                        "source": "relation_hint",
+                        "raw_label": label,
+                        "object_type": entity_type,
+                    },
+                )
+            )
+            observations.append(
+                observation(
+                    "alias",
+                    attr,
+                    f"Map source field '{attr}' to relation '{predicate}'.",
+                    0.66,
+                    url,
+                    title,
+                    label,
+                    {**evidence_base, "source": "relation_hint", "target": predicate},
+                )
+            )
+
+    return observations
+
+
+def observation(
+    candidate_type: str,
+    name: str,
+    description: str,
+    confidence: float,
+    url: str,
+    title: str | None,
+    snippet: str,
+    metadata: dict[str, Any],
+) -> CandidateObservation:
+    return CandidateObservation(
+        candidate_type=candidate_type,
+        name=name[:160],
+        description=description,
+        confidence=confidence,
+        evidence=CandidateEvidence(url=url, title=title, snippet=clean_snippet(snippet), metadata=metadata),
+        metadata=metadata,
+    )
+
+
+def soup_from_html(html: str):
+    from bs4 import BeautifulSoup
+
+    return BeautifulSoup(html or "", "html.parser")
+
+
+def collect_json_ld_schema(soup) -> tuple[Counter[str], Counter[str]]:
+    types: Counter[str] = Counter()
+    keys: Counter[str] = Counter()
+    for tag in soup.find_all("script"):
+        script_type = " ".join(str(item) for item in tag.get("type", "").split()).lower()
+        if "ld+json" not in script_type:
+            continue
+        raw = tag.string or tag.get_text(" ", strip=True)
+        try:
+            payload = json.loads(raw)
+        except Exception:
+            continue
+        visit_json_ld(payload, types, keys)
+    return types, keys
+
+
+def visit_json_ld(value: Any, types: Counter[str], keys: Counter[str]) -> None:
+    if isinstance(value, list):
+        for item in value:
+            visit_json_ld(item, types, keys)
+        return
+    if not isinstance(value, dict):
+        return
+    for key, nested in value.items():
+        if key == "@type":
+            for item in ensure_list(nested):
+                if isinstance(item, str) and is_schema_name(item):
+                    types[item] += 1
+        elif not key.startswith("@"):
+            keys[key] += 1
+            visit_json_ld(nested, types, keys)
+
+
+def collect_structural_labels(soup, text: str) -> Counter[str]:
+    labels: Counter[str] = Counter()
+    for selector in ["th", "dt", "label", "[itemprop]", "[property]", "[name]"]:
+        for node in soup.select(selector):
+            label = ""
+            if selector == "[itemprop]":
+                label = node.get("itemprop", "")
+            elif selector == "[property]":
+                label = str(node.get("property", "")).split(":")[-1]
+            elif selector == "[name]":
+                label = str(node.get("name", "")).split(":")[-1]
+            else:
+                label = node.get_text(" ", strip=True)
+            add_label(labels, label)
+
+    for line in text.splitlines()[:500]:
+        match = re.match(r"^\s*([^:：|]{2,40})\s*[:：|]\s*(.{1,200})$", line)
+        if match:
+            add_label(labels, match.group(1))
+    return labels
+
+
+def add_label(labels: Counter[str], label: str) -> None:
+    cleaned = clean_label(label)
+    if cleaned and not is_noisy_label(cleaned):
+        labels[cleaned] += 1
+
+
+def relation_hint(label: str) -> tuple[str, str] | None:
+    lowered = label.lower()
+    for token, hint in RELATION_HINTS.items():
+        if token in lowered:
+            return hint
+    return None
+
+
+def entity_type_from_page_type(page_type: str) -> str | None:
+    mapping = {
+        "ProductPage": "Product",
+        "CategoryPage": "Category",
+        "BrandStoryPage": "Brand",
+        "NoticePage": "Notice",
+        "PromotionPage": "Promotion",
+        "ReviewPage": "Review",
+        "BoardPage": "Article",
+    }
+    return mapping.get(page_type)
+
+
+def attribute_name(label: str) -> str:
+    cleaned = clean_label(label)
+    if not cleaned or is_noisy_label(cleaned):
+        return ""
+    if re.search(r"[가-힣]", cleaned):
+        return re.sub(r"[\s/()-]+", "_", cleaned).strip("_")[:80]
+    words = re.findall(r"[A-Za-z0-9]+", cleaned)
+    if not words:
+        return ""
+    return "_".join(word.lower() for word in words)[:80]
+
+
+def pascal_case(value: str) -> str:
+    cleaned = clean_label(value)
+    parts = re.findall(r"[A-Za-z0-9가-힣]+", cleaned)
+    if not parts:
+        return ""
+    return "".join(part[:1].upper() + part[1:] for part in parts)[:80]
+
+
+def clean_label(value: str) -> str:
+    return re.sub(r"\s+", " ", str(value or "").replace("\xa0", " ")).strip(" -_*:/|")
+
+
+def is_schema_name(value: str) -> bool:
+    return 1 <= len(value) <= 80 and not value.startswith("http")
+
+
+def is_noisy_label(value: str) -> bool:
+    lowered = value.lower().strip()
+    if len(lowered) < 2 or len(lowered) > 80:
+        return True
+    noisy = {
+        "class",
+        "style",
+        "viewport",
+        "charset",
+        "csrf-token",
+        "description",
+        "keywords",
+        "robots",
+        "generator",
+        "theme-color",
+    }
+    return lowered in noisy or lowered.startswith("twitter:")
+
+
+def clean_snippet(value: str) -> str:
+    return re.sub(r"\s+", " ", str(value or "")).strip()[:1000]
+
+
+def first_sentence(text: str) -> str:
+    cleaned = clean_snippet(text)
+    for delimiter in [". ", "\n", "。", "다."]:
+        if delimiter in cleaned:
+            return cleaned.split(delimiter, 1)[0][:240]
+    return cleaned[:240]
+
+
+def normalize_url(url: str) -> str:
+    return str(url or "").strip().rstrip("/")
+
+
+def seed_host(url: str) -> str:
+    return urlparse(url).netloc.lower()
+
+
+def ensure_list(value: Any) -> list[Any]:
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def merge_metadata(items) -> dict[str, Any]:
+    merged: dict[str, Any] = {}
+    sources: set[str] = set()
+    targets: set[str] = set()
+    object_types: set[str] = set()
+    for item in items:
+        merged.update(item or {})
+        if item.get("source"):
+            sources.add(str(item["source"]))
+        if item.get("target"):
+            targets.add(str(item["target"]))
+        if item.get("object_type"):
+            object_types.add(str(item["object_type"]))
+    if sources:
+        merged["sources"] = sorted(sources)
+    if targets:
+        merged["targets"] = sorted(targets)
+    if object_types:
+        merged["object_types"] = sorted(object_types)
+    return merged
diff --git a/ontology_platform/web/frontend/src/App.tsx b/ontology_platform/web/frontend/src/App.tsx
index 51ff222..36c1b51 100644
--- a/ontology_platform/web/frontend/src/App.tsx
+++ b/ontology_platform/web/frontend/src/App.tsx
@@ -1,6 +1,7 @@
 import { Routes, Route } from "react-router-dom";
 import AppShell from "@/components/layout/AppShell";
 import OnboardingPage from "@/pages/OnboardingPage";
+import DomainBuilderPage from "@/pages/DomainBuilderPage";
 import ConfigureSourcesPage from "@/pages/ConfigureSourcesPage";
 import CrawlPage from "@/pages/CrawlPage";
 import ResearchPage from "@/pages/ResearchPage";
@@ -20,6 +21,7 @@ function App() {
       <Route element={<AppShell />}>
         <Route path="/" element={<DashboardPage />} />
         <Route path="/onboard" element={<OnboardingPage />} />
+        <Route path="/domains" element={<DomainBuilderPage />} />
         <Route path="/sources/:projectId" element={<ConfigureSourcesPage />} />
         <Route path="/crawl/:projectId" element={<CrawlPage />} />
         <Route path="/pipeline/:projectId" element={<BuildPipelinePage />} />
diff --git a/ontology_platform/web/frontend/src/components/layout/navigation.ts b/ontology_platform/web/frontend/src/components/layout/navigation.ts
index f1e6ada..a2c4182 100644
--- a/ontology_platform/web/frontend/src/components/layout/navigation.ts
+++ b/ontology_platform/web/frontend/src/components/layout/navigation.ts
@@ -5,6 +5,7 @@ import {
   ClipboardCheck,
   Code2,
   GitBranch,
+  Globe2,
   Layers3,
   LayoutDashboard,
   ListChecks,
@@ -66,6 +67,15 @@ export const NAV_GROUPS: NavGroup[] = [
         keywords: ["create", "start", "wizard"],
         shortcut: "g n",
       },
+      {
+        id: "domains",
+        to: "/domains",
+        labelKey: "nav.domains",
+        label: "Domain Builder",
+        icon: Globe2,
+        keywords: ["domain", "schema", "reference", "crawler"],
+        shortcut: "g m",
+      },
     ],
   },
   {
diff --git a/ontology_platform/web/frontend/src/components/ui/data-table.tsx b/ontology_platform/web/frontend/src/components/ui/data-table.tsx
index 524a6ea..2d03c0f 100644
--- a/ontology_platform/web/frontend/src/components/ui/data-table.tsx
+++ b/ontology_platform/web/frontend/src/components/ui/data-table.tsx
@@ -808,6 +808,7 @@ function TableShell<T>({
                     scope="col"
                     style={{
                       width: header.getSize(),
+                      maxWidth: header.getSize(),
                       ...getPinStyle(col, "header"),
                     }}
                     aria-sort={
@@ -921,16 +922,19 @@ function TableShell<T>({
                         key={cell.id}
                         style={{
                           width: col.getSize(),
+                          maxWidth: col.getSize(),
                           ...getPinStyle(col, "cell"),
                         }}
                         className={cn(
                           cellPadClass,
                           alignClass,
-                          "text-foreground",
+                          "overflow-hidden text-foreground align-middle",
                           pinned && "bg-surface",
                         )}
                       >
-                        {flexRender(col.columnDef.cell, cell.getContext())}
+                        <div className="min-w-0 break-words">
+                          {flexRender(col.columnDef.cell, cell.getContext())}
+                        </div>
                       </td>
                     );
                   })}
diff --git a/ontology_platform/web/frontend/src/components/ui/dialog.tsx b/ontology_platform/web/frontend/src/components/ui/dialog.tsx
index 7400fef..7031cba 100644
--- a/ontology_platform/web/frontend/src/components/ui/dialog.tsx
+++ b/ontology_platform/web/frontend/src/components/ui/dialog.tsx
@@ -92,7 +92,7 @@ export const DialogPanel = React.forwardRef<HTMLDivElement, DialogPanelProps>(
             "fixed left-1/2 top-1/2 z-50 -translate-x-1/2 -translate-y-1/2",
             "flex max-h-[90vh] w-full max-w-lg flex-col overflow-hidden",
             "rounded-xl border border-border bg-surface-raised shadow-xl outline-none",
-            "data-[state=open]:animate-fade-in-up",
+            "data-[state=open]:animate-fade-in",
             className,
           )}
           {...props}
diff --git a/ontology_platform/web/frontend/src/hooks/useDomains.ts b/ontology_platform/web/frontend/src/hooks/useDomains.ts
index 861f5d3..4bca78e 100644
--- a/ontology_platform/web/frontend/src/hooks/useDomains.ts
+++ b/ontology_platform/web/frontend/src/hooks/useDomains.ts
@@ -1,5 +1,14 @@
-import { useQuery } from "@tanstack/react-query";
-import { domainsApi, DomainSummary } from "@/lib/api/domains";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  domainsApi,
+  DomainDefinitionRequest,
+  DomainDefinitionUpdateRequest,
+  DomainDiscoveryJob,
+  DomainDiscoveryRequest,
+  DomainReferenceSource,
+  DomainCandidate,
+  DomainSummary,
+} from "@/lib/api/domains";
 import { ontologyApi, OntologyDetail } from "@/lib/api/ontology";
 import { queryKeys } from "./queryKeys";
 
@@ -11,6 +20,151 @@ export function useDomains() {
   });
 }
 
+export function useCreateDomain() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (body: DomainDefinitionRequest) => domainsApi.create(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.domains.all });
+      queryClient.invalidateQueries({ queryKey: queryKeys.ontology.all });
+    },
+  });
+}
+
+export function useUpdateDomain() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      domain,
+      body,
+    }: {
+      domain: string;
+      body: DomainDefinitionUpdateRequest;
+    }) => domainsApi.update(domain, body),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.domains.all });
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.ontology.byDomain(variables.domain),
+      });
+    },
+  });
+}
+
+export function useDomainDiscoveryJobs(domain: string | undefined) {
+  return useQuery<DomainDiscoveryJob[]>({
+    queryKey: [...queryKeys.domains.all, "discoveryJobs", domain ?? ""],
+    queryFn: () => domainsApi.discoveryJobs(domain!),
+    enabled: Boolean(domain),
+    refetchInterval: (query) => {
+      const jobs = query.state.data;
+      return jobs?.some((job) => ["pending", "running", "cancel_requested"].includes(job.status))
+        ? 2000
+        : false;
+    },
+  });
+}
+
+export function useDomainReferenceSources(domain: string | undefined) {
+  return useQuery<DomainReferenceSource[]>({
+    queryKey: [...queryKeys.domains.all, "referenceSources", domain ?? ""],
+    queryFn: () => domainsApi.referenceSources(domain!),
+    enabled: Boolean(domain),
+  });
+}
+
+export function useDomainCandidates(domain: string | undefined) {
+  return useQuery<DomainCandidate[]>({
+    queryKey: [...queryKeys.domains.all, "candidates", domain ?? ""],
+    queryFn: () => domainsApi.candidates(domain!),
+    enabled: Boolean(domain),
+    refetchInterval: 2000,
+  });
+}
+
+export function useStartDomainDiscovery() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      domain,
+      body,
+    }: {
+      domain: string;
+      body: DomainDiscoveryRequest;
+    }) => domainsApi.startDiscovery(domain, body),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: [...queryKeys.domains.all, "discoveryJobs", variables.domain],
+      });
+      queryClient.invalidateQueries({
+        queryKey: [...queryKeys.domains.all, "referenceSources", variables.domain],
+      });
+      queryClient.invalidateQueries({
+        queryKey: [...queryKeys.domains.all, "candidates", variables.domain],
+      });
+    },
+  });
+}
+
+export function useCancelDomainDiscovery() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      domain,
+      jobId,
+    }: {
+      domain: string;
+      jobId: string;
+    }) => domainsApi.cancelDiscovery(domain, jobId),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: [...queryKeys.domains.all, "discoveryJobs", variables.domain],
+      });
+    },
+  });
+}
+
+export function useApplyDomainCandidates() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      domain,
+      candidateIds,
+    }: {
+      domain: string;
+      candidateIds: string[];
+    }) => domainsApi.applyCandidates(domain, candidateIds),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.domains.all });
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.ontology.byDomain(variables.domain),
+      });
+      queryClient.invalidateQueries({
+        queryKey: [...queryKeys.domains.all, "candidates", variables.domain],
+      });
+    },
+  });
+}
+
+export function useUpdateDomainCandidateStatus() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({
+      domain,
+      candidateId,
+      status,
+    }: {
+      domain: string;
+      candidateId: string;
+      status: "pending_review" | "approved" | "rejected";
+    }) => domainsApi.updateCandidateStatus(domain, candidateId, status),
+    onSuccess: (_data, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: [...queryKeys.domains.all, "candidates", variables.domain],
+      });
+    },
+  });
+}
+
 export function useOntology(domain: string | undefined) {
   return useQuery<OntologyDetail>({
     queryKey: queryKeys.ontology.byDomain(domain ?? ""),
diff --git a/ontology_platform/web/frontend/src/hooks/useProjects.ts b/ontology_platform/web/frontend/src/hooks/useProjects.ts
index 6c2cb63..434d5e2 100644
--- a/ontology_platform/web/frontend/src/hooks/useProjects.ts
+++ b/ontology_platform/web/frontend/src/hooks/useProjects.ts
@@ -43,3 +43,31 @@ export function useCreateProjectInline() {
     },
   });
 }
+
+export function useResetProject() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (projectName: string) => projectsApi.reset(projectName),
+    onSuccess: (_data, projectName) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.projects.all });
+      queryClient.invalidateQueries({
+        queryKey: queryKeys.projects.detail(projectName),
+      });
+      queryClient.invalidateQueries({ queryKey: queryKeys.platform.all });
+    },
+  });
+}
+
+export function useDeleteProject() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (projectName: string) => projectsApi.delete(projectName),
+    onSuccess: (_data, projectName) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.projects.all });
+      queryClient.removeQueries({
+        queryKey: queryKeys.projects.detail(projectName),
+      });
+      queryClient.invalidateQueries({ queryKey: queryKeys.platform.all });
+    },
+  });
+}
diff --git a/ontology_platform/web/frontend/src/lib/api/domains.ts b/ontology_platform/web/frontend/src/lib/api/domains.ts
index cb42a0d..2af051e 100644
--- a/ontology_platform/web/frontend/src/lib/api/domains.ts
+++ b/ontology_platform/web/frontend/src/lib/api/domains.ts
@@ -3,15 +3,177 @@ import { apiClient } from "./client";
 
 export const domainSummarySchema = z.object({
   domain: z.string(),
+  description: z.string().nullable().optional(),
   entity_types: z.array(z.string()),
   predicates: z.array(z.string()),
   attribute_count: z.number().int(),
+  attributes: z.array(z.string()).default([]),
+  aliases: z.record(z.string(), z.string()).default({}),
+  is_builtin: z.boolean().default(false),
+  is_custom: z.boolean().default(false),
 });
 
 export const domainListSchema = z.array(domainSummarySchema);
 
 export type DomainSummary = z.infer<typeof domainSummarySchema>;
 
+export const domainDiscoveryJobSchema = z.object({
+  job_id: z.union([z.string(), z.number()]).transform(String),
+  domain: z.string(),
+  status: z.string(),
+  seed_urls: z.array(z.string()).default([]),
+  max_pages: z.number(),
+  max_depth: z.number(),
+  same_domain_only: z.boolean(),
+  fetcher: z.string(),
+  respect_robots_txt: z.boolean(),
+  error: z.string().nullable().optional(),
+  progress: z.record(z.unknown()).default({}),
+  result_summary: z.record(z.unknown()).default({}),
+  created_at: z.string().nullable().optional(),
+  started_at: z.string().nullable().optional(),
+  finished_at: z.string().nullable().optional(),
+});
+
+export const domainReferenceSourceSchema = z.object({
+  id: z.union([z.string(), z.number()]).transform(String),
+  domain: z.string(),
+  url: z.string(),
+  label: z.string().nullable().optional(),
+  status: z.string(),
+  last_crawled_at: z.string().nullable().optional(),
+  metadata: z.record(z.unknown()).default({}),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+});
+
+export const domainCandidateEvidenceSchema = z.object({
+  id: z.union([z.string(), z.number()]).transform(String),
+  job_id: z.union([z.string(), z.number()]).nullable().optional().transform((v) =>
+    v == null ? null : String(v),
+  ),
+  url: z.string(),
+  title: z.string().nullable().optional(),
+  snippet: z.string(),
+  metadata: z.record(z.unknown()).default({}),
+  created_at: z.string().nullable().optional(),
+});
+
+export const domainCandidateSchema = z.object({
+  id: z.union([z.string(), z.number()]).transform(String),
+  domain: z.string(),
+  job_id: z.union([z.string(), z.number()]).nullable().optional().transform((v) =>
+    v == null ? null : String(v),
+  ),
+  candidate_type: z.string(),
+  name: z.string(),
+  description: z.string().nullable().optional(),
+  confidence: z.number(),
+  occurrence_count: z.number(),
+  status: z.string(),
+  metadata: z.record(z.unknown()).default({}),
+  evidence: z.array(domainCandidateEvidenceSchema).default([]),
+  created_at: z.string().nullable().optional(),
+  updated_at: z.string().nullable().optional(),
+});
+
+export const domainDiscoveryJobListSchema = z.array(domainDiscoveryJobSchema);
+export const domainReferenceSourceListSchema = z.array(domainReferenceSourceSchema);
+export const domainCandidateListSchema = z.array(domainCandidateSchema);
+export const domainCandidateApplyResponseSchema = z.object({
+  ok: z.boolean(),
+  domain: z.string(),
+  applied: z.record(z.number()),
+  definition: domainSummarySchema,
+});
+
+export type DomainDiscoveryJob = z.infer<typeof domainDiscoveryJobSchema>;
+export type DomainReferenceSource = z.infer<typeof domainReferenceSourceSchema>;
+export type DomainCandidate = z.infer<typeof domainCandidateSchema>;
+export type DomainCandidateApplyResponse = z.infer<
+  typeof domainCandidateApplyResponseSchema
+>;
+
+export interface DomainDefinitionRequest {
+  domain: string;
+  description?: string | null;
+  entity_types: string[];
+  predicates: string[];
+  attributes: string[];
+  aliases?: Record<string, string>;
+}
+
+export type DomainDefinitionUpdateRequest = Omit<
+  DomainDefinitionRequest,
+  "domain"
+>;
+
+export interface DomainDiscoveryRequest {
+  seed_urls: string[];
+  max_pages?: number;
+  max_depth?: number;
+  same_domain_only?: boolean;
+  fetcher?: string;
+  respect_robots_txt?: boolean;
+  force_recrawl?: boolean;
+}
+
 export const domainsApi = {
   list: () => apiClient.get("/domains", domainListSchema),
+  create: (body: DomainDefinitionRequest) =>
+    apiClient.post("/domains", domainSummarySchema, body),
+  update: (domain: string, body: DomainDefinitionUpdateRequest) =>
+    apiClient.put(
+      `/domains/${encodeURIComponent(domain)}`,
+      domainSummarySchema,
+      body,
+    ),
+  discoveryJobs: (domain: string) =>
+    apiClient.get(
+      `/domains/${encodeURIComponent(domain)}/discovery/jobs`,
+      domainDiscoveryJobListSchema,
+    ),
+  referenceSources: (domain: string) =>
+    apiClient.get(
+      `/domains/${encodeURIComponent(domain)}/reference-sources`,
+      domainReferenceSourceListSchema,
+    ),
+  startDiscovery: (domain: string, body: DomainDiscoveryRequest) =>
+    apiClient.post(
+      `/domains/${encodeURIComponent(domain)}/discovery/jobs`,
+      domainDiscoveryJobSchema,
+      body,
+    ),
+  discoveryJob: (domain: string, jobId: string) =>
+    apiClient.get(
+      `/domains/${encodeURIComponent(domain)}/discovery/jobs/${encodeURIComponent(jobId)}`,
+      domainDiscoveryJobSchema,
+    ),
+  cancelDiscovery: (domain: string, jobId: string) =>
+    apiClient.post(
+      `/domains/${encodeURIComponent(domain)}/discovery/jobs/${encodeURIComponent(jobId)}/cancel`,
+      domainDiscoveryJobSchema,
+    ),
+  candidates: (domain: string, status?: string) =>
+    apiClient.get(
+      `/domains/${encodeURIComponent(domain)}/candidates`,
+      domainCandidateListSchema,
+      { query: { status } },
+    ),
+  applyCandidates: (domain: string, candidateIds: string[]) =>
+    apiClient.post(
+      `/domains/${encodeURIComponent(domain)}/candidates/apply`,
+      domainCandidateApplyResponseSchema,
+      { candidate_ids: candidateIds.map(Number) },
+    ),
+  updateCandidateStatus: (
+    domain: string,
+    candidateId: string,
+    status: "pending_review" | "approved" | "rejected",
+  ) =>
+    apiClient.post(
+      `/domains/${encodeURIComponent(domain)}/candidates/${encodeURIComponent(candidateId)}/status`,
+      domainCandidateSchema,
+      { status },
+    ),
 };
diff --git a/ontology_platform/web/frontend/src/lib/api/projects.ts b/ontology_platform/web/frontend/src/lib/api/projects.ts
index 12c7bfc..202d3a5 100644
--- a/ontology_platform/web/frontend/src/lib/api/projects.ts
+++ b/ontology_platform/web/frontend/src/lib/api/projects.ts
@@ -35,9 +35,17 @@ export const createProjectResponseSchema = z.object({
   domain: z.string(),
 });
 
+export const projectActionResponseSchema = z.object({
+  ok: z.boolean(),
+  name: z.string(),
+  domain: z.string().optional(),
+  deleted: z.record(z.number()).optional(),
+});
+
 export type ProjectSummary = z.infer<typeof projectSummarySchema>;
 export type ProjectDetail = z.infer<typeof projectDetailSchema>;
 export type ProjectSource = z.infer<typeof projectSourceSchema>;
+export type ProjectActionResponse = z.infer<typeof projectActionResponseSchema>;
 
 export interface CreateProjectRequest {
   config_path: string;
@@ -77,4 +85,14 @@ export const projectsApi = {
     apiClient.post("/projects", createProjectResponseSchema, body),
   createInline: (body: CreateProjectInlineRequest) =>
     apiClient.post("/projects/inline", createProjectResponseSchema, body),
+  reset: (projectName: string) =>
+    apiClient.post(
+      `/projects/${encodeURIComponent(projectName)}/reset`,
+      projectActionResponseSchema,
+    ),
+  delete: (projectName: string) =>
+    apiClient.delete(
+      `/projects/${encodeURIComponent(projectName)}`,
+      projectActionResponseSchema,
+    ),
 };
diff --git a/ontology_platform/web/frontend/src/pages/DashboardPage.tsx b/ontology_platform/web/frontend/src/pages/DashboardPage.tsx
index 4f1666c..50e8af4 100644
--- a/ontology_platform/web/frontend/src/pages/DashboardPage.tsx
+++ b/ontology_platform/web/frontend/src/pages/DashboardPage.tsx
@@ -1,6 +1,15 @@
 import { useNavigate } from "react-router-dom";
 import { useTranslation } from "react-i18next";
-import { Plus, FolderOpen, AlertCircle, Clock } from "lucide-react";
+import { useState } from "react";
+import { toast } from "sonner";
+import {
+  Plus,
+  FolderOpen,
+  AlertCircle,
+  Clock,
+  DatabaseZap,
+  Trash2,
+} from "lucide-react";
 import {
   Card,
   CardContent,
@@ -9,8 +18,21 @@ import {
   CardTitle,
 } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogBody,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogPanel,
+  DialogTitle,
+} from "@/components/ui/dialog";
 import { Skeleton } from "@/components/ui/skeleton";
-import { useProjects } from "@/hooks/useProjects";
+import {
+  useDeleteProject,
+  useProjects,
+  useResetProject,
+} from "@/hooks/useProjects";
 import { usePipeline } from "@/hooks/usePlatform";
 import { formatPercent } from "@/lib/display";
 import { ProjectSummary } from "@/lib/api/projects";
@@ -128,6 +150,11 @@ function ProjectCard({
   onOpen: (path: string) => void;
 }) {
   const pipeline = usePipeline(project.name);
+  const resetProject = useResetProject();
+  const deleteProject = useDeleteProject();
+  const [confirmAction, setConfirmAction] = useState<"reset" | "delete" | null>(
+    null,
+  );
   const claimStage = pipeline.data?.stages.find((stage) => stage.key === "claims");
   const approvedStage = pipeline.data?.stages.find(
     (stage) => stage.key === "validated",
@@ -136,35 +163,136 @@ function ProjectCard({
   const claimCount = claimStage?.count ?? 0;
   const approvedCount = approvedStage?.count ?? 0;
   const approvalRate = claimCount > 0 ? approvedCount / claimCount : 0;
+  const isDeleting = deleteProject.isPending;
+  const isResetting = resetProject.isPending;
+
+  const handleProjectAction = async () => {
+    if (!confirmAction) return;
+    try {
+      if (confirmAction === "reset") {
+        await resetProject.mutateAsync(project.name);
+        toast.success(`${project.name} 데이터가 초기화되었습니다`);
+      } else {
+        await deleteProject.mutateAsync(project.name);
+        toast.success(`${project.name} 프로젝트가 삭제되었습니다`);
+      }
+      setConfirmAction(null);
+    } catch (error) {
+      toast.error((error as Error).message);
+    }
+  };
 
   return (
-    <Card
-      role="button"
-      tabIndex={0}
-      onClick={() => onOpen(`/sources/${project.name}`)}
-      onKeyDown={(e) => {
-        if (e.key === "Enter" || e.key === " ") {
-          onOpen(`/sources/${project.name}`);
-        }
-      }}
-      className="cursor-pointer transition-colors hover:bg-accent/40"
-    >
-      <CardHeader>
-        <CardTitle>{project.name}</CardTitle>
-        <CardDescription>{project.domain}</CardDescription>
-      </CardHeader>
-      <CardContent>
-        <div className="grid grid-cols-3 gap-2 text-xs">
-          <ProjectStat label="Pages" value={pageStage?.count ?? 0} />
-          <ProjectStat label="Claims" value={claimCount} />
-          <ProjectStat label="Approved" value={formatPercent(approvalRate)} />
+    <>
+      <Card
+        role="button"
+        tabIndex={0}
+        onClick={() => onOpen(`/sources/${project.name}`)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" || e.key === " ") {
+            onOpen(`/sources/${project.name}`);
+          }
+        }}
+        className="relative cursor-pointer transition-colors hover:bg-accent/40"
+      >
+        <div className="absolute right-3 top-3 z-10 flex items-center gap-1">
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            className="h-8 w-8 text-muted-foreground hover:text-foreground"
+            aria-label={`${project.name} 데이터 초기화`}
+            title="데이터 초기화"
+            disabled={isDeleting || isResetting}
+            onClick={(e) => {
+              e.stopPropagation();
+              setConfirmAction("reset");
+            }}
+          >
+            <DatabaseZap className="h-4 w-4" />
+          </Button>
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            className="h-8 w-8 text-muted-foreground hover:bg-destructive/10 hover:text-destructive"
+            aria-label={`${project.name} 프로젝트 삭제`}
+            title="프로젝트 삭제"
+            disabled={isDeleting || isResetting}
+            onClick={(e) => {
+              e.stopPropagation();
+              setConfirmAction("delete");
+            }}
+          >
+            <Trash2 className="h-4 w-4" />
+          </Button>
         </div>
-        <div className="mt-3 flex items-center gap-2 text-xs text-muted-foreground">
-          <Clock className="h-3 w-3" />
-          {formatRelative(project.updated_at)}
-        </div>
-      </CardContent>
-    </Card>
+        <CardHeader className="pr-24">
+          <CardTitle>{project.name}</CardTitle>
+          <CardDescription>{project.domain}</CardDescription>
+        </CardHeader>
+        <CardContent>
+          <div className="grid grid-cols-3 gap-2 text-xs">
+            <ProjectStat label="Pages" value={pageStage?.count ?? 0} />
+            <ProjectStat label="Claims" value={claimCount} />
+            <ProjectStat label="Approved" value={formatPercent(approvalRate)} />
+          </div>
+          <div className="mt-3 flex items-center gap-2 text-xs text-muted-foreground">
+            <Clock className="h-3 w-3" />
+            {formatRelative(project.updated_at)}
+          </div>
+        </CardContent>
+      </Card>
+
+      <Dialog
+        open={confirmAction !== null}
+        onOpenChange={(open) => {
+          if (!open && !isDeleting && !isResetting) setConfirmAction(null);
+        }}
+        ariaLabel="프로젝트 작업 확인"
+      >
+        <DialogPanel>
+          <DialogHeader onClose={() => setConfirmAction(null)}>
+            <DialogTitle>
+              {confirmAction === "delete" ? "프로젝트 삭제" : "데이터 초기화"}
+            </DialogTitle>
+            <DialogDescription>
+              {confirmAction === "delete"
+                ? "프로젝트와 연결된 모든 데이터가 삭제됩니다."
+                : "프로젝트는 유지하고 크롤링/엔티티/클레임 데이터를 초기화합니다."}
+            </DialogDescription>
+          </DialogHeader>
+          <DialogBody>
+            <p className="text-sm">
+              <span className="font-semibold">{project.name}</span>
+              {confirmAction === "delete"
+                ? " 프로젝트를 삭제할까요?"
+                : " 데이터를 초기화할까요?"}
+            </p>
+          </DialogBody>
+          <DialogFooter>
+            <Button
+              variant={confirmAction === "delete" ? "destructive" : "default"}
+              onClick={handleProjectAction}
+              disabled={isDeleting || isResetting}
+            >
+              {isDeleting || isResetting
+                ? "처리 중..."
+                : confirmAction === "delete"
+                  ? "삭제"
+                  : "초기화"}
+            </Button>
+            <Button
+              variant="outline"
+              onClick={() => setConfirmAction(null)}
+              disabled={isDeleting || isResetting}
+            >
+              취소
+            </Button>
+          </DialogFooter>
+        </DialogPanel>
+      </Dialog>
+    </>
   );
 }
 
diff --git a/ontology_platform/web/frontend/src/pages/DomainBuilderPage.tsx b/ontology_platform/web/frontend/src/pages/DomainBuilderPage.tsx
new file mode 100644
index 0000000..1b8b991
--- /dev/null
+++ b/ontology_platform/web/frontend/src/pages/DomainBuilderPage.tsx
@@ -0,0 +1,1082 @@
+import { useEffect, useMemo, useState } from "react";
+import type { ReactNode } from "react";
+import { useSearchParams } from "react-router-dom";
+import {
+  Ban,
+  Check,
+  Globe2,
+  Loader2,
+  Plus,
+  RefreshCw,
+  SearchCheck,
+  X,
+} from "lucide-react";
+import { toast } from "sonner";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Skeleton } from "@/components/ui/skeleton";
+import { Textarea } from "@/components/ui/textarea";
+import {
+  useApplyDomainCandidates,
+  useCancelDomainDiscovery,
+  useCreateDomain,
+  useDomainCandidates,
+  useDomainDiscoveryJobs,
+  useDomainReferenceSources,
+  useDomains,
+  useStartDomainDiscovery,
+  useUpdateDomain,
+  useUpdateDomainCandidateStatus,
+} from "@/hooks/useDomains";
+import type {
+  DomainCandidate,
+  DomainDiscoveryJob,
+  DomainReferenceSource,
+  DomainSummary,
+} from "@/lib/api/domains";
+import { cn } from "@/lib/utils";
+
+type SchemaKind = "entity_type" | "predicate" | "attribute" | "alias";
+type SchemaPayload = Pick<
+  DomainSummary,
+  "entity_types" | "predicates" | "attributes" | "aliases"
+>;
+
+const CANDIDATE_LABELS: Record<string, string> = {
+  entity_type: "엔티티",
+  predicate: "관계",
+  attribute: "속성",
+  alias: "별칭",
+};
+
+const JOB_STATUS_LABELS: Record<string, string> = {
+  pending: "대기 중",
+  running: "분석 중",
+  cancel_requested: "취소 중",
+  canceled: "취소됨",
+  completed: "완료",
+  failed: "실패",
+};
+
+const COMPLETION_REASON_LABELS: Record<string, string> = {
+  no_more_links: "더 탐색할 링크가 없어 완료되었습니다.",
+  max_pages_reached: "설정한 최대 페이지 수에 도달해 완료되었습니다.",
+  interrupted: "서버 재시작으로 실행 중이던 분석이 중단되었습니다. 다시 분석을 시작하세요.",
+  canceled: "사용자 요청으로 분석이 취소되었습니다.",
+};
+
+function parseLines(value: string): string[] {
+  const seen = new Set<string>();
+  return value
+    .split(/\n|,/)
+    .map((item) => item.trim())
+    .filter((item) => {
+      if (!item || seen.has(item)) return false;
+      seen.add(item);
+      return true;
+    });
+}
+
+function uniqueSorted(values: string[]): string[] {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean))).sort();
+}
+
+function numberValue(value: unknown, fallback = 0): number {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.map(String) : [];
+}
+
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function pendingIds(candidates: DomainCandidate[] | undefined): string[] {
+  return (candidates ?? [])
+    .filter((candidate) => candidate.status === "pending_review")
+    .map((candidate) => candidate.id);
+}
+
+function groupedCandidates(candidates: DomainCandidate[] | undefined) {
+  const groups: Record<string, DomainCandidate[]> = {
+    entity_type: [],
+    predicate: [],
+    attribute: [],
+    alias: [],
+  };
+  for (const candidate of candidates ?? []) {
+    if (!groups[candidate.candidate_type]) groups[candidate.candidate_type] = [];
+    groups[candidate.candidate_type].push(candidate);
+  }
+  return groups;
+}
+
+export default function DomainBuilderPage() {
+  const [searchParams, setSearchParams] = useSearchParams();
+  const { data: domains, isLoading: domainsLoading } = useDomains();
+  const createDomain = useCreateDomain();
+  const updateDomain = useUpdateDomain();
+  const startDiscovery = useStartDomainDiscovery();
+  const cancelDiscovery = useCancelDomainDiscovery();
+  const applyCandidates = useApplyDomainCandidates();
+  const updateCandidateStatus = useUpdateDomainCandidateStatus();
+
+  const selectedDomainName =
+    searchParams.get("domain") || domains?.[0]?.domain || "";
+  const selectedDomain = domains?.find(
+    (domain) => domain.domain === selectedDomainName,
+  );
+  const { data: referenceSources, refetch: refetchReferenceSources } =
+    useDomainReferenceSources(selectedDomainName || undefined);
+  const { data: jobs, refetch: refetchJobs } =
+    useDomainDiscoveryJobs(selectedDomainName || undefined);
+  const { data: candidates, refetch: refetchCandidates } =
+    useDomainCandidates(selectedDomainName || undefined);
+
+  const [newDomain, setNewDomain] = useState("");
+  const [newDescription, setNewDescription] = useState("");
+  const [seedUrls, setSeedUrls] = useState("");
+  const [maxPages, setMaxPages] = useState(20);
+  const [maxDepth, setMaxDepth] = useState(1);
+  const [sameDomainOnly, setSameDomainOnly] = useState(true);
+  const [forceRecrawl, setForceRecrawl] = useState(false);
+  const [selectedCandidateIds, setSelectedCandidateIds] = useState<string[]>([]);
+  const [schemaDrafts, setSchemaDrafts] = useState<Record<SchemaKind, string>>({
+    entity_type: "",
+    predicate: "",
+    attribute: "",
+    alias: "",
+  });
+
+  useEffect(() => {
+    setSelectedCandidateIds([]);
+  }, [selectedDomainName]);
+
+  const latestJob = jobs?.[0];
+  const activeJob = jobs?.find((job) =>
+    ["pending", "running", "cancel_requested"].includes(job.status),
+  );
+  const groups = useMemo(() => groupedCandidates(candidates), [candidates]);
+  const pendingCandidateIds = useMemo(() => pendingIds(candidates), [candidates]);
+  const pendingCount = pendingCandidateIds.length;
+  const analyzedUrls = useMemo(
+    () =>
+      new Set(
+        (referenceSources ?? [])
+          .filter((source) => source.last_crawled_at)
+          .map((source) => source.url),
+      ),
+    [referenceSources],
+  );
+  const typedUrls = parseLines(seedUrls);
+  const duplicateTypedUrls = typedUrls.filter((url) => analyzedUrls.has(url));
+
+  const selectDomain = (domain: string) => {
+    setSearchParams({ domain });
+  };
+
+  const refreshAll = () => {
+    void refetchJobs();
+    void refetchCandidates();
+    void refetchReferenceSources();
+  };
+
+  const createNewDomain = async () => {
+    const domain = newDomain.trim().toLowerCase();
+    if (!domain) {
+      toast.error("도메인 ID를 입력하세요.");
+      return;
+    }
+    try {
+      const created = await createDomain.mutateAsync({
+        domain,
+        description: newDescription.trim() || null,
+        entity_types: [],
+        predicates: [],
+        attributes: [],
+        aliases: {},
+      });
+      toast.success("도메인을 만들고 선택했습니다.");
+      setNewDomain("");
+      setNewDescription("");
+      selectDomain(created.domain);
+    } catch (error) {
+      toast.error((error as Error).message);
+    }
+  };
+
+  const updateDomainSchema = async (next: SchemaPayload, message: string) => {
+    if (!selectedDomain) return;
+    try {
+      await updateDomain.mutateAsync({
+        domain: selectedDomain.domain,
+        body: {
+          description: selectedDomain.description ?? null,
+          entity_types: next.entity_types,
+          predicates: next.predicates,
+          attributes: next.attributes,
+          aliases: next.aliases,
+        },
+      });
+      toast.success(message);
+      refreshAll();
+    } catch (error) {
+      toast.error((error as Error).message);
+    }
+  };
+
+  const addSchemaItem = async (kind: SchemaKind) => {
+    if (!selectedDomain) {
+      toast.error("먼저 도메인을 선택하세요.");
+      return;
+    }
+    const rawValue = schemaDrafts[kind].trim();
+    if (!rawValue) {
+      toast.error("추가할 값을 입력하세요.");
+      return;
+    }
+
+    const next: SchemaPayload = {
+      entity_types: [...selectedDomain.entity_types],
+      predicates: [...selectedDomain.predicates],
+      attributes: [...selectedDomain.attributes],
+      aliases: { ...selectedDomain.aliases },
+    };
+
+    if (kind === "entity_type") {
+      next.entity_types = uniqueSorted([...next.entity_types, rawValue]);
+    } else if (kind === "predicate") {
+      next.predicates = uniqueSorted([...next.predicates, rawValue]);
+    } else if (kind === "attribute") {
+      next.attributes = uniqueSorted([...next.attributes, rawValue]);
+    } else {
+      const [rawKey, ...rawTarget] = rawValue.split("=");
+      const key = rawKey.trim();
+      const target = rawTarget.join("=").trim();
+      if (!key || !target) {
+        toast.error("별칭은 source=target 형식으로 입력하세요.");
+        return;
+      }
+      next.aliases[key] = target;
+    }
+
+    await updateDomainSchema(next, "도메인 스키마에 추가했습니다.");
+    setSchemaDrafts((current) => ({ ...current, [kind]: "" }));
+  };
+
+  const removeSchemaItem = async (kind: SchemaKind, value: string) => {
+    if (!selectedDomain) return;
+    const next: SchemaPayload = {
+      entity_types: [...selectedDomain.entity_types],
+      predicates: [...selectedDomain.predicates],
+      attributes: [...selectedDomain.attributes],
+      aliases: { ...selectedDomain.aliases },
+    };
+
+    if (kind === "entity_type") {
+      next.entity_types = next.entity_types.filter((item) => item !== value);
+    } else if (kind === "predicate") {
+      next.predicates = next.predicates.filter((item) => item !== value);
+      for (const [alias, target] of Object.entries(next.aliases)) {
+        if (target === value) delete next.aliases[alias];
+      }
+    } else if (kind === "attribute") {
+      next.attributes = next.attributes.filter((item) => item !== value);
+    } else {
+      delete next.aliases[value];
+    }
+
+    await updateDomainSchema(next, "도메인 스키마에서 삭제했습니다.");
+  };
+
+  const runDiscovery = async () => {
+    if (!selectedDomainName) {
+      toast.error("먼저 도메인을 선택하거나 생성하세요.");
+      return;
+    }
+    const urls = parseLines(seedUrls);
+    if (urls.length === 0) {
+      toast.error("참고 사이트 URL을 1개 이상 입력하세요.");
+      return;
+    }
+    try {
+      const job = await startDiscovery.mutateAsync({
+        domain: selectedDomainName,
+        body: {
+          seed_urls: urls,
+          max_pages: maxPages,
+          max_depth: maxDepth,
+          same_domain_only: sameDomainOnly,
+          fetcher: "requests",
+          respect_robots_txt: false,
+          force_recrawl: forceRecrawl,
+        },
+      });
+      const skipped = stringArray(job.progress.skipped_seed_urls);
+      if (skipped.length > 0 && job.status === "completed") {
+        toast.success("이미 분석한 참고 사이트라 재크롤링을 건너뛰었습니다.");
+      } else if (skipped.length > 0) {
+        toast.success(`${skipped.length}개 중복 URL을 제외하고 분석을 시작했습니다.`);
+      } else {
+        toast.success("참고 사이트 분석을 시작했습니다.");
+      }
+      setSeedUrls("");
+      refreshAll();
+    } catch (error) {
+      toast.error((error as Error).message);
+    }
+  };
+
+  const cancelActiveJob = async () => {
+    if (!selectedDomainName || !activeJob) return;
+    try {
+      await cancelDiscovery.mutateAsync({
+        domain: selectedDomainName,
+        jobId: activeJob.job_id,
+      });
+      toast.success("분석 취소를 요청했습니다.");
+      void refetchJobs();
+    } catch (error) {
+      toast.error((error as Error).message);
+    }
+  };
+
+  const toggleCandidate = (candidateId: string) => {
+    setSelectedCandidateIds((current) =>
+      current.includes(candidateId)
+        ? current.filter((id) => id !== candidateId)
+        : [...current, candidateId],
+    );
+  };
+
+  const selectAllPending = () => {
+    setSelectedCandidateIds(pendingCandidateIds);
+  };
+
+  const clearSelected = () => {
+    setSelectedCandidateIds([]);
+  };
+
+  const toggleGroup = (rows: DomainCandidate[]) => {
+    const ids = rows
+      .filter((candidate) => candidate.status === "pending_review")
+      .map((candidate) => candidate.id);
+    const allSelected = ids.every((id) => selectedCandidateIds.includes(id));
+    setSelectedCandidateIds((current) =>
+      allSelected
+        ? current.filter((id) => !ids.includes(id))
+        : Array.from(new Set([...current, ...ids])),
+    );
+  };
+
+  const applySelected = async () => {
+    if (!selectedDomainName || selectedCandidateIds.length === 0) return;
+    try {
+      const result = await applyCandidates.mutateAsync({
+        domain: selectedDomainName,
+        candidateIds: selectedCandidateIds,
+      });
+      const total = Object.values(result.applied).reduce((sum, value) => sum + value, 0);
+      toast.success(`${total}개 후보를 도메인에 반영했습니다.`);
+      setSelectedCandidateIds([]);
+      refreshAll();
+    } catch (error) {
+      toast.error((error as Error).message);
+    }
+  };
+
+  const rejectCandidate = async (candidateId: string) => {
+    if (!selectedDomainName) return;
+    try {
+      await updateCandidateStatus.mutateAsync({
+        domain: selectedDomainName,
+        candidateId,
+        status: "rejected",
+      });
+      toast.success("후보를 제외했습니다.");
+    } catch (error) {
+      toast.error((error as Error).message);
+    }
+  };
+
+  return (
+    <div className="mx-auto max-w-7xl px-6 py-8">
+      <div className="mb-6 flex flex-col gap-3 sm:flex-row sm:items-end sm:justify-between">
+        <div>
+          <h1 className="text-2xl font-bold tracking-tight">도메인 관리</h1>
+          <p className="mt-1 text-sm text-muted-foreground">
+            도메인을 선택하거나 생성한 뒤 현재 스키마를 직접 편집하고, 참고 사이트 분석에서 발견한 후보를 검토해 반영합니다.
+          </p>
+        </div>
+        <Button type="button" variant="outline" onClick={refreshAll}>
+          <RefreshCw className="h-4 w-4" />
+          새로고침
+        </Button>
+      </div>
+
+      <div className="grid gap-5 lg:grid-cols-[300px_minmax(0,1fr)]">
+        <aside className="space-y-4">
+          <StepCard step="1" title="도메인 선택">
+            {domainsLoading && <Skeleton className="h-40" />}
+            <div className="space-y-2">
+              {(domains ?? []).map((domain) => (
+                <button
+                  key={domain.domain}
+                  type="button"
+                  onClick={() => selectDomain(domain.domain)}
+                  className={cn(
+                    "w-full rounded-md border px-3 py-2 text-left text-sm transition-colors",
+                    selectedDomainName === domain.domain
+                      ? "border-primary bg-accent text-foreground"
+                      : "border-border text-muted-foreground hover:bg-accent/50 hover:text-foreground",
+                  )}
+                >
+                  <div className="flex items-center justify-between gap-2">
+                    <span className="truncate font-medium">{domain.domain}</span>
+                    {domain.is_custom && <Badge variant="secondary">custom</Badge>}
+                  </div>
+                  <div className="mt-1 text-xs">
+                    엔티티 {domain.entity_types.length} · 관계 {domain.predicates.length}
+                  </div>
+                </button>
+              ))}
+            </div>
+          </StepCard>
+
+          <StepCard step="+" title="새 도메인 생성">
+            <div className="space-y-3">
+              <div className="space-y-1.5">
+                <Label htmlFor="new-domain">도메인 ID</Label>
+                <Input
+                  id="new-domain"
+                  value={newDomain}
+                  placeholder="cosmetic_ingredient"
+                  onChange={(event) => setNewDomain(event.target.value)}
+                />
+              </div>
+              <div className="space-y-1.5">
+                <Label htmlFor="new-domain-description">설명</Label>
+                <Input
+                  id="new-domain-description"
+                  value={newDescription}
+                  placeholder="화장품 성분 분석"
+                  onChange={(event) => setNewDescription(event.target.value)}
+                />
+              </div>
+              <Button
+                type="button"
+                className="w-full"
+                onClick={createNewDomain}
+                disabled={createDomain.isPending}
+              >
+                {createDomain.isPending ? (
+                  <Loader2 className="h-4 w-4 animate-spin" />
+                ) : (
+                  <Plus className="h-4 w-4" />
+                )}
+                도메인 생성 후 선택
+              </Button>
+            </div>
+          </StepCard>
+        </aside>
+
+        <main className="space-y-5">
+          <CurrentDomainPanel
+            domain={selectedDomain}
+            drafts={schemaDrafts}
+            saving={updateDomain.isPending}
+            onDraftChange={(kind, value) =>
+              setSchemaDrafts((current) => ({ ...current, [kind]: value }))
+            }
+            onAdd={addSchemaItem}
+            onRemove={removeSchemaItem}
+          />
+
+          <Card>
+            <CardHeader>
+              <CardTitle className="flex items-center gap-2 text-base">
+                <Globe2 className="h-4 w-4" />
+                2. 참고 사이트 분석
+              </CardTitle>
+            </CardHeader>
+            <CardContent className="space-y-4">
+              <ReferenceSourcesPanel sources={referenceSources ?? []} />
+              <div className="grid gap-4 lg:grid-cols-[minmax(0,1fr)_240px]">
+                <div className="space-y-2">
+                  <Label htmlFor="seed-urls">새 참고 URL</Label>
+                  <Textarea
+                    id="seed-urls"
+                    value={seedUrls}
+                    className="min-h-[132px]"
+                    placeholder={"https://example.com/products/sample\nhttps://example.com/category/ingredients"}
+                    onChange={(event) => setSeedUrls(event.target.value)}
+                    disabled={Boolean(activeJob)}
+                  />
+                  <p className="text-xs text-muted-foreground">
+                    한 줄에 하나씩 입력하세요. 이미 분석한 URL은 저장되어 기본적으로 다시 크롤링하지 않습니다.
+                  </p>
+                  {duplicateTypedUrls.length > 0 && !forceRecrawl && (
+                    <p className="text-xs text-yellow-600">
+                      입력한 URL 중 {duplicateTypedUrls.length}개는 이미 분석되어 건너뜁니다.
+                    </p>
+                  )}
+                </div>
+                <div className="space-y-3">
+                  <div className="grid grid-cols-2 gap-3">
+                    <div className="space-y-1.5">
+                      <Label htmlFor="max-pages">페이지</Label>
+                      <Input
+                        id="max-pages"
+                        type="number"
+                        min={1}
+                        max={200}
+                        value={maxPages}
+                        disabled={Boolean(activeJob)}
+                        onChange={(event) => setMaxPages(Number(event.target.value))}
+                      />
+                    </div>
+                    <div className="space-y-1.5">
+                      <Label htmlFor="max-depth">깊이</Label>
+                      <Input
+                        id="max-depth"
+                        type="number"
+                        min={0}
+                        max={5}
+                        value={maxDepth}
+                        disabled={Boolean(activeJob)}
+                        onChange={(event) => setMaxDepth(Number(event.target.value))}
+                      />
+                    </div>
+                  </div>
+                  <label className="flex items-center gap-2 rounded-md border px-3 py-2 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={sameDomainOnly}
+                      disabled={Boolean(activeJob)}
+                      onChange={(event) => setSameDomainOnly(event.target.checked)}
+                    />
+                    동일 도메인만 탐색
+                  </label>
+                  <label className="flex items-center gap-2 rounded-md border px-3 py-2 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={forceRecrawl}
+                      disabled={Boolean(activeJob)}
+                      onChange={(event) => setForceRecrawl(event.target.checked)}
+                    />
+                    저장된 URL도 다시 분석
+                  </label>
+                  <div className="grid grid-cols-2 gap-2">
+                    <Button
+                      type="button"
+                      onClick={runDiscovery}
+                      disabled={!selectedDomainName || startDiscovery.isPending || Boolean(activeJob)}
+                    >
+                      {startDiscovery.isPending ? (
+                        <Loader2 className="h-4 w-4 animate-spin" />
+                      ) : (
+                        <SearchCheck className="h-4 w-4" />
+                      )}
+                      분석 시작
+                    </Button>
+                    <Button
+                      type="button"
+                      variant="outline"
+                      onClick={cancelActiveJob}
+                      disabled={!activeJob || cancelDiscovery.isPending}
+                    >
+                      <Ban className="h-4 w-4" />
+                      취소
+                    </Button>
+                  </div>
+                </div>
+              </div>
+            </CardContent>
+          </Card>
+
+          <DiscoveryStatusPanel latestJob={latestJob} pendingCount={pendingCount} />
+
+          <Card>
+            <CardHeader>
+              <div className="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+                <div>
+                  <CardTitle className="text-base">3. 스키마 후보 검토</CardTitle>
+                  <p className="mt-1 text-xs text-muted-foreground">
+                    분석 중에도 후보가 실시간으로 추가됩니다. 필요한 항목만 선택하거나 전체 선택 후 도메인에 반영하세요.
+                  </p>
+                </div>
+                <div className="flex flex-wrap gap-2">
+                  <Button
+                    type="button"
+                    variant="outline"
+                    onClick={selectAllPending}
+                    disabled={pendingCandidateIds.length === 0}
+                  >
+                    전체 선택 ({pendingCandidateIds.length})
+                  </Button>
+                  <Button
+                    type="button"
+                    variant="outline"
+                    onClick={clearSelected}
+                    disabled={selectedCandidateIds.length === 0}
+                  >
+                    선택 해제
+                  </Button>
+                  <Button
+                    type="button"
+                    onClick={applySelected}
+                    disabled={selectedCandidateIds.length === 0 || applyCandidates.isPending}
+                  >
+                    {applyCandidates.isPending && (
+                      <Loader2 className="h-4 w-4 animate-spin" />
+                    )}
+                    선택 반영 ({selectedCandidateIds.length})
+                  </Button>
+                </div>
+              </div>
+            </CardHeader>
+            <CardContent className="space-y-5">
+              {Object.entries(groups).map(([type, rows]) => (
+                <CandidateGroup
+                  key={type}
+                  type={type}
+                  rows={rows}
+                  selectedIds={selectedCandidateIds}
+                  onToggle={toggleCandidate}
+                  onToggleGroup={() => toggleGroup(rows)}
+                  onReject={rejectCandidate}
+                />
+              ))}
+            </CardContent>
+          </Card>
+        </main>
+      </div>
+    </div>
+  );
+}
+
+function StepCard({
+  step,
+  title,
+  children,
+}: {
+  step: string;
+  title: string;
+  children: ReactNode;
+}) {
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2 text-sm">
+          <span className="flex h-5 w-5 items-center justify-center rounded-full bg-brand-600 text-[10px] font-bold text-white">
+            {step}
+          </span>
+          {title}
+        </CardTitle>
+      </CardHeader>
+      <CardContent>{children}</CardContent>
+    </Card>
+  );
+}
+
+function CurrentDomainPanel({
+  domain,
+  drafts,
+  saving,
+  onDraftChange,
+  onAdd,
+  onRemove,
+}: {
+  domain?: DomainSummary;
+  drafts: Record<SchemaKind, string>;
+  saving: boolean;
+  onDraftChange: (kind: SchemaKind, value: string) => void;
+  onAdd: (kind: SchemaKind) => void;
+  onRemove: (kind: SchemaKind, value: string) => void;
+}) {
+  if (!domain) {
+    return (
+      <Card>
+        <CardContent className="py-8 text-sm text-muted-foreground">
+          먼저 왼쪽에서 도메인을 선택하거나 새 도메인을 만드세요.
+        </CardContent>
+      </Card>
+    );
+  }
+
+  return (
+    <Card>
+      <CardHeader>
+        <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
+          <CardTitle className="text-base">현재 도메인 편집: {domain.domain}</CardTitle>
+          <div className="flex gap-2">
+            {domain.is_builtin && <Badge variant="outline">기본 템플릿</Badge>}
+            {domain.is_custom && <Badge variant="secondary">사용자 수정</Badge>}
+          </div>
+        </div>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        <p className="text-xs text-muted-foreground">
+          현재 도메인에 들어간 엔티티, 관계, 속성, 별칭을 직접 추가하거나 삭제할 수 있습니다. 별칭은 source=target 형식으로 입력합니다.
+        </p>
+        <div className="grid gap-4 lg:grid-cols-2">
+          <SchemaEditor
+            title="엔티티"
+            kind="entity_type"
+            values={domain.entity_types}
+            draft={drafts.entity_type}
+            placeholder="Ingredient"
+            saving={saving}
+            onDraftChange={onDraftChange}
+            onAdd={onAdd}
+            onRemove={onRemove}
+          />
+          <SchemaEditor
+            title="관계"
+            kind="predicate"
+            values={domain.predicates}
+            draft={drafts.predicate}
+            placeholder="hasIngredient"
+            saving={saving}
+            onDraftChange={onDraftChange}
+            onAdd={onAdd}
+            onRemove={onRemove}
+          />
+          <SchemaEditor
+            title="속성"
+            kind="attribute"
+            values={domain.attributes}
+            draft={drafts.attribute}
+            placeholder="concentration"
+            saving={saving}
+            onDraftChange={onDraftChange}
+            onAdd={onAdd}
+            onRemove={onRemove}
+          />
+          <SchemaEditor
+            title="별칭"
+            kind="alias"
+            values={Object.entries(domain.aliases).map(([key, value]) => `${key}=${value}`)}
+            draft={drafts.alias}
+            placeholder="ingredients=hasIngredient"
+            saving={saving}
+            onDraftChange={onDraftChange}
+            onAdd={onAdd}
+            onRemove={(kind, value) => onRemove(kind, value.split("=")[0])}
+          />
+        </div>
+      </CardContent>
+    </Card>
+  );
+}
+
+function SchemaEditor({
+  title,
+  kind,
+  values,
+  draft,
+  placeholder,
+  saving,
+  onDraftChange,
+  onAdd,
+  onRemove,
+}: {
+  title: string;
+  kind: SchemaKind;
+  values: string[];
+  draft: string;
+  placeholder: string;
+  saving: boolean;
+  onDraftChange: (kind: SchemaKind, value: string) => void;
+  onAdd: (kind: SchemaKind) => void;
+  onRemove: (kind: SchemaKind, value: string) => void;
+}) {
+  return (
+    <div className="rounded-lg border bg-background p-3">
+      <div className="mb-2 flex items-center justify-between gap-2">
+        <div className="text-xs font-semibold text-muted-foreground">{title}</div>
+        <Badge variant="outline">{values.length}개</Badge>
+      </div>
+      <div className="mb-3 flex gap-2">
+        <Input
+          value={draft}
+          placeholder={placeholder}
+          onChange={(event) => onDraftChange(kind, event.target.value)}
+          onKeyDown={(event) => {
+            if (event.key === "Enter") {
+              event.preventDefault();
+              void onAdd(kind);
+            }
+          }}
+          disabled={saving}
+        />
+        <Button type="button" onClick={() => void onAdd(kind)} disabled={saving || !draft.trim()}>
+          {saving ? <Loader2 className="h-4 w-4 animate-spin" /> : <Plus className="h-4 w-4" />}
+          추가
+        </Button>
+      </div>
+      <div className="flex max-h-36 flex-wrap gap-1.5 overflow-y-auto">
+        {values.length === 0 ? (
+          <span className="text-xs text-muted-foreground">아직 없음</span>
+        ) : (
+          values.map((value) => (
+            <span
+              key={value}
+              className="inline-flex items-center gap-1 rounded-md border bg-card px-2 py-1 text-xs"
+            >
+              <span>{value}</span>
+              <button
+                type="button"
+                className="rounded-sm text-muted-foreground hover:text-destructive"
+                onClick={() => void onRemove(kind, value)}
+                disabled={saving}
+                aria-label={`${value} 삭제`}
+                title="삭제"
+              >
+                <X className="h-3 w-3" />
+              </button>
+            </span>
+          ))
+        )}
+      </div>
+    </div>
+  );
+}
+
+function ReferenceSourcesPanel({ sources }: { sources: DomainReferenceSource[] }) {
+  return (
+    <div className="rounded-lg border bg-background px-4 py-3">
+      <div className="mb-2 flex items-center justify-between gap-3">
+        <div className="text-sm font-semibold">저장된 참고 사이트</div>
+        <Badge variant="outline">{sources.length}개</Badge>
+      </div>
+      {sources.length === 0 ? (
+        <p className="text-xs text-muted-foreground">
+          아직 저장된 참고 사이트가 없습니다. 분석을 시작하면 자동 저장됩니다.
+        </p>
+      ) : (
+        <div className="flex max-h-24 flex-col gap-1 overflow-y-auto">
+          {sources.map((source) => (
+            <div key={source.id} className="flex items-center justify-between gap-3 text-xs">
+              <span className="truncate text-muted-foreground">{source.url}</span>
+              <span className="shrink-0 text-muted-foreground">
+                {source.last_crawled_at ? "분석됨" : "저장됨"}
+              </span>
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}
+
+function DiscoveryStatusPanel({
+  latestJob,
+  pendingCount,
+}: {
+  latestJob?: DomainDiscoveryJob;
+  pendingCount: number;
+}) {
+  const progress = latestJob?.progress ?? {};
+  const visited = numberValue(progress.visited_count);
+  const maxPages = numberValue(progress.max_pages, latestJob?.max_pages ?? 0);
+  const queued = numberValue(progress.queued_count);
+  const candidates = numberValue(progress.candidate_count);
+  const observations = numberValue(progress.observation_count);
+  const isTerminal = latestJob
+    ? ["completed", "failed", "canceled"].includes(latestJob.status)
+    : false;
+  const rawPercent = maxPages > 0 ? Math.round((visited / maxPages) * 100) : 0;
+  const percent = isTerminal ? 100 : Math.min(rawPercent, 99);
+  const statusLabel = latestJob
+    ? JOB_STATUS_LABELS[latestJob.status] ?? latestJob.status
+    : "없음";
+  const completionReason = stringValue(progress.completion_reason);
+  const completionMessage = isTerminal
+    ? COMPLETION_REASON_LABELS[completionReason] ??
+      (latestJob?.status === "completed"
+        ? queued === 0 && visited < maxPages
+          ? "더 탐색할 링크가 없어 완료되었습니다."
+          : "요청한 범위 분석이 완료되었습니다."
+        : "")
+    : "";
+  const skipped = stringArray(progress.skipped_seed_urls);
+
+  return (
+    <Card>
+      <CardContent className="space-y-4 py-4">
+        <div className="grid gap-3 sm:grid-cols-4">
+          <Metric label="최근 작업" value={statusLabel} />
+          <Metric label="방문 페이지" value={`${visited}/${maxPages || "-"}`} />
+          <Metric label="발견 후보" value={String(candidates)} />
+          <Metric label="검토 대기" value={String(pendingCount)} />
+        </div>
+        <div>
+          <div className="mb-1 flex items-center justify-between text-xs text-muted-foreground">
+            <span>{isTerminal ? "작업 상태" : "분석 진행률"}</span>
+            <span>{percent}% · 방문 {visited} · 대기 {queued} · 관찰 {observations}</span>
+          </div>
+          <div className="h-3 overflow-hidden rounded-full bg-muted">
+            <div
+              className="h-full rounded-full bg-brand-600 transition-all"
+              style={{ width: `${percent}%` }}
+            />
+          </div>
+        </div>
+        {skipped.length > 0 && (
+          <div className="rounded-md border border-border px-3 py-2 text-xs text-muted-foreground">
+            이미 분석되어 건너뛴 URL: {skipped.slice(0, 3).join(", ")}
+            {skipped.length > 3 && ` 외 ${skipped.length - 3}개`}
+          </div>
+        )}
+        {completionMessage && (
+          <div className="rounded-md border border-border px-3 py-2 text-xs text-muted-foreground">
+            {completionMessage} 방문 페이지 수는 실제 발견된 링크 수이며, 최대 페이지 수는 상한값입니다.
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}
+
+function Metric({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="rounded-lg border bg-card px-4 py-3">
+      <div className="text-xs text-muted-foreground">{label}</div>
+      <div className="mt-1 text-lg font-semibold">{value}</div>
+    </div>
+  );
+}
+
+function CandidateGroup({
+  type,
+  rows,
+  selectedIds,
+  onToggle,
+  onToggleGroup,
+  onReject,
+}: {
+  type: string;
+  rows: DomainCandidate[];
+  selectedIds: string[];
+  onToggle: (id: string) => void;
+  onToggleGroup: () => void;
+  onReject: (id: string) => void;
+}) {
+  const pendingRows = rows.filter((candidate) => candidate.status === "pending_review");
+  const allGroupSelected =
+    pendingRows.length > 0 &&
+    pendingRows.every((candidate) => selectedIds.includes(candidate.id));
+
+  return (
+    <section>
+      <div className="mb-2 flex items-center justify-between gap-3">
+        <h2 className="text-sm font-semibold">
+          {CANDIDATE_LABELS[type] ?? type}
+          <span className="ml-2 text-xs text-muted-foreground">{rows.length}개</span>
+        </h2>
+        <Button
+          type="button"
+          variant="outline"
+          size="sm"
+          onClick={onToggleGroup}
+          disabled={pendingRows.length === 0}
+        >
+          {allGroupSelected ? "그룹 해제" : "그룹 선택"}
+        </Button>
+      </div>
+      {rows.length === 0 ? (
+        <div className="rounded-md border border-dashed px-4 py-6 text-center text-sm text-muted-foreground">
+          아직 후보가 없습니다.
+        </div>
+      ) : (
+        <div className="space-y-2">
+          {rows.map((candidate) => (
+            <CandidateRow
+              key={candidate.id}
+              candidate={candidate}
+              selected={selectedIds.includes(candidate.id)}
+              onToggle={() => onToggle(candidate.id)}
+              onReject={() => onReject(candidate.id)}
+            />
+          ))}
+        </div>
+      )}
+    </section>
+  );
+}
+
+function CandidateRow({
+  candidate,
+  selected,
+  onToggle,
+  onReject,
+}: {
+  candidate: DomainCandidate;
+  selected: boolean;
+  onToggle: () => void;
+  onReject: () => void;
+}) {
+  const disabled = candidate.status !== "pending_review";
+  const evidence = candidate.evidence[0];
+
+  return (
+    <div
+      className={cn(
+        "rounded-lg border p-3 transition-colors",
+        selected && "border-primary bg-accent/50",
+        disabled && "opacity-70",
+      )}
+    >
+      <div className="flex items-start gap-3">
+        <input
+          type="checkbox"
+          className="mt-1"
+          checked={selected}
+          disabled={disabled}
+          onChange={onToggle}
+          aria-label={`${candidate.name} 선택`}
+        />
+        <div className="min-w-0 flex-1">
+          <div className="flex flex-wrap items-center gap-2">
+            <span className="font-medium">{candidate.name}</span>
+            <Badge variant={candidate.status === "approved" ? "success" : "outline"}>
+              {candidate.status}
+            </Badge>
+            <span className="text-xs text-muted-foreground">
+              신뢰도 {Math.round(candidate.confidence * 100)}% · {candidate.occurrence_count}회
+            </span>
+          </div>
+          {candidate.description && (
+            <p className="mt-1 text-sm text-muted-foreground">
+              {candidate.description}
+            </p>
+          )}
+          {evidence && (
+            <div className="mt-2 rounded-md bg-background px-3 py-2 text-xs text-muted-foreground">
+              <div className="truncate font-medium text-foreground">{evidence.url}</div>
+              <div className="mt-1 line-clamp-2">{evidence.snippet}</div>
+            </div>
+          )}
+        </div>
+        {candidate.status === "pending_review" ? (
+          <Button type="button" variant="ghost" size="icon" onClick={onReject}>
+            <X className="h-4 w-4" />
+          </Button>
+        ) : (
+          <Check className="mt-1 h-4 w-4 text-muted-foreground" />
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/ontology_platform/web/frontend/src/pages/OnboardingPage.tsx b/ontology_platform/web/frontend/src/pages/OnboardingPage.tsx
index 9c3af4f..89a4cfe 100644
--- a/ontology_platform/web/frontend/src/pages/OnboardingPage.tsx
+++ b/ontology_platform/web/frontend/src/pages/OnboardingPage.tsx
@@ -1,10 +1,11 @@
+import { useEffect, useState } from "react";
 import { useNavigate } from "react-router-dom";
 import { useTranslation } from "react-i18next";
 import { useForm } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { z } from "zod";
 import { toast } from "sonner";
-import { AlertCircle, ArrowLeft, Loader2 } from "lucide-react";
+import { AlertCircle, ArrowLeft, Loader2, Pencil, Plus } from "lucide-react";
 import {
   Card,
   CardContent,
@@ -12,30 +13,235 @@ import {
   CardHeader,
   CardTitle,
 } from "@/components/ui/card";
+import {
+  Dialog,
+  DialogBody,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogPanel,
+  DialogTitle,
+} from "@/components/ui/dialog";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Skeleton } from "@/components/ui/skeleton";
-import { useDomains } from "@/hooks/useDomains";
+import { Textarea } from "@/components/ui/textarea";
+import {
+  useCreateDomain,
+  useDomains,
+  useUpdateDomain,
+} from "@/hooks/useDomains";
 import { useCreateProjectInline } from "@/hooks/useProjects";
+import { DomainSummary } from "@/lib/api/domains";
 import { cn } from "@/lib/utils";
 
 const projectNameRegex = /^[a-zA-Z0-9_-]+$/;
+const domainNameRegex = /^[a-z0-9][a-z0-9_-]{1,79}$/;
 
 const schema = z.object({
   project_name: z
     .string()
-    .min(2, "최소 2자 이상")
-    .max(64, "최대 64자")
-    .regex(projectNameRegex, "영문/숫자/_/- 만 허용"),
-  domain: z.string().min(1, "도메인을 선택하세요"),
+    .min(2, "At least 2 characters")
+    .max(64, "Up to 64 characters")
+    .regex(projectNameRegex, "Use letters, numbers, underscore, or hyphen"),
+  domain: z.string().min(1, "Select a domain"),
 });
 
 type FormValues = z.infer<typeof schema>;
 
+interface DomainEditorState {
+  mode: "create" | "edit";
+  domain?: DomainSummary;
+}
+
+function parseList(value: string): string[] {
+  const seen = new Set<string>();
+  return value
+    .split(/[\n,]/)
+    .map((item) => item.trim())
+    .filter((item) => {
+      if (!item || seen.has(item)) return false;
+      seen.add(item);
+      return true;
+    });
+}
+
+function formatList(values: string[] | undefined): string {
+  return (values ?? []).join("\n");
+}
+
+function parseAliases(value: string): Record<string, string> {
+  const aliases: Record<string, string> = {};
+  for (const line of value.split("\n")) {
+    const [rawKey, ...rawValue] = line.split("=");
+    const key = rawKey?.trim();
+    const aliasValue = rawValue.join("=").trim();
+    if (key && aliasValue) aliases[key] = aliasValue;
+  }
+  return aliases;
+}
+
+function formatAliases(values: Record<string, string> | undefined): string {
+  return Object.entries(values ?? {})
+    .map(([key, value]) => `${key}=${value}`)
+    .join("\n");
+}
+
+function DomainEditorDialog({
+  state,
+  onClose,
+  onSelect,
+}: {
+  state: DomainEditorState | null;
+  onClose: () => void;
+  onSelect: (domain: string) => void;
+}) {
+  const createDomain = useCreateDomain();
+  const updateDomain = useUpdateDomain();
+  const editing = state?.mode === "edit";
+  const domain = state?.domain;
+
+  const [name, setName] = useState("");
+  const [description, setDescription] = useState("");
+  const [entityTypes, setEntityTypes] = useState("");
+  const [predicates, setPredicates] = useState("");
+  const [attributes, setAttributes] = useState("");
+  const [aliases, setAliases] = useState("");
+
+  useEffect(() => {
+    if (!state) return;
+    setName(domain?.domain ?? "");
+    setDescription(domain?.description ?? "");
+    setEntityTypes(formatList(domain?.entity_types));
+    setPredicates(formatList(domain?.predicates));
+    setAttributes(formatList(domain?.attributes));
+    setAliases(formatAliases(domain?.aliases));
+  }, [domain, state]);
+
+  const saving = createDomain.isPending || updateDomain.isPending;
+
+  const save = async () => {
+    const normalized = name.trim().toLowerCase();
+    if (!domainNameRegex.test(normalized)) {
+      toast.error("도메인은 소문자, 숫자, _, - 조합의 2~80자로 입력하세요.");
+      return;
+    }
+    const body = {
+      description: description.trim() || null,
+      entity_types: parseList(entityTypes),
+      predicates: parseList(predicates),
+      attributes: parseList(attributes),
+      aliases: parseAliases(aliases),
+    };
+    if (body.entity_types.length === 0) {
+      toast.error("엔티티 타입을 최소 1개 이상 입력하세요.");
+      return;
+    }
+    try {
+      const saved = editing
+        ? await updateDomain.mutateAsync({ domain: normalized, body })
+        : await createDomain.mutateAsync({ domain: normalized, ...body });
+      toast.success(editing ? "도메인을 수정했습니다." : "도메인을 생성했습니다.");
+      onSelect(saved.domain);
+      onClose();
+    } catch (e) {
+      toast.error((e as Error).message);
+    }
+  };
+
+  return (
+    <Dialog open={Boolean(state)} onOpenChange={(open) => !open && onClose()}>
+      <DialogPanel ariaLabel={editing ? "도메인 편집" : "도메인 생성"} className="max-w-2xl">
+        <DialogHeader onClose={onClose}>
+          <DialogTitle>{editing ? "도메인 편집" : "새 도메인 생성"}</DialogTitle>
+          <DialogDescription>
+            프로젝트에서 반복해서 사용할 엔티티, 관계, 속성 템플릿을 정의합니다.
+          </DialogDescription>
+        </DialogHeader>
+        <DialogBody className="space-y-4">
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="space-y-2">
+              <Label htmlFor="domain-name">도메인 ID</Label>
+              <Input
+                id="domain-name"
+                value={name}
+                disabled={editing}
+                placeholder="cosmetic_ingredient"
+                onChange={(event) => setName(event.target.value)}
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="domain-description">설명</Label>
+              <Input
+                id="domain-description"
+                value={description}
+                placeholder="화장품 성분 지식 그래프"
+                onChange={(event) => setDescription(event.target.value)}
+              />
+            </div>
+          </div>
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="space-y-2">
+              <Label htmlFor="domain-entities">엔티티 타입</Label>
+              <Textarea
+                id="domain-entities"
+                value={entityTypes}
+                className="min-h-[160px]"
+                placeholder={"Ingredient\nBrand\nProduct\nSkinConcern"}
+                onChange={(event) => setEntityTypes(event.target.value)}
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="domain-predicates">관계</Label>
+              <Textarea
+                id="domain-predicates"
+                value={predicates}
+                className="min-h-[160px]"
+                placeholder={"hasIngredient\nsuitableForSkinType\nhasWarning"}
+                onChange={(event) => setPredicates(event.target.value)}
+              />
+            </div>
+          </div>
+          <div className="grid gap-4 sm:grid-cols-2">
+            <div className="space-y-2">
+              <Label htmlFor="domain-attributes">속성</Label>
+              <Textarea
+                id="domain-attributes"
+                value={attributes}
+                placeholder={"name\nsource_url\nupdated_at\nconfidence"}
+                onChange={(event) => setAttributes(event.target.value)}
+              />
+            </div>
+            <div className="space-y-2">
+              <Label htmlFor="domain-aliases">별칭 매핑</Label>
+              <Textarea
+                id="domain-aliases"
+                value={aliases}
+                placeholder={"ingredients=hasIngredient\nwarnings=hasWarning"}
+                onChange={(event) => setAliases(event.target.value)}
+              />
+            </div>
+          </div>
+        </DialogBody>
+        <DialogFooter>
+          <Button type="button" onClick={save} disabled={saving}>
+            {saving && <Loader2 className="h-4 w-4 animate-spin" />}
+            저장
+          </Button>
+          <Button type="button" variant="outline" onClick={onClose} disabled={saving}>
+            취소
+          </Button>
+        </DialogFooter>
+      </DialogPanel>
+    </Dialog>
+  );
+}
+
 export default function OnboardingPage() {
   const navigate = useNavigate();
   const { t } = useTranslation();
+  const [editorState, setEditorState] = useState<DomainEditorState | null>(null);
   const {
     data: domains,
     isLoading: domainsLoading,
@@ -65,6 +271,15 @@ export default function OnboardingPage() {
         project_name: values.project_name,
         domain: values.domain,
         target_entities: selected?.entity_types ?? [],
+        fields: selected?.attributes ?? [],
+        ontology: selected
+          ? {
+              entity_types: selected.entity_types,
+              predicates: selected.predicates,
+              attributes: selected.attributes,
+              aliases: selected.aliases,
+            }
+          : {},
       });
       toast.success(
         t("onboarding.created", "프로젝트가 생성되었습니다: {{name}}", {
@@ -99,29 +314,33 @@ export default function OnboardingPage() {
 
       <Card>
         <CardHeader>
-          <CardTitle>
-            {t("onboarding.formTitle", "온톨로지 도메인 선택")}
-          </CardTitle>
-          <CardDescription>
-            {t(
-              "onboarding.formDesc",
-              "어떤 종류의 온톨로지를 구축할지 도메인을 선택하고 프로젝트 이름을 정해주세요.",
-            )}
-          </CardDescription>
+          <div className="flex flex-col gap-3 sm:flex-row sm:items-start sm:justify-between">
+            <div>
+              <CardTitle>{t("onboarding.formTitle", "온톨로지 도메인 선택")}</CardTitle>
+              <CardDescription>
+                도메인을 선택하거나 새로 만들어 프로젝트의 기본 스키마로 사용합니다.
+              </CardDescription>
+            </div>
+            <div className="flex flex-wrap gap-2">
+              <Button type="button" variant="outline" onClick={() => navigate("/domains")}>
+                도메인 관리
+              </Button>
+              <Button type="button" variant="outline" onClick={() => setEditorState({ mode: "create" })}>
+                <Plus className="h-4 w-4" />
+                빠른 생성
+              </Button>
+            </div>
+          </div>
         </CardHeader>
         <CardContent>
-          <form
-            onSubmit={handleSubmit(onSubmit)}
-            className="space-y-6"
-            noValidate
-          >
+          <form onSubmit={handleSubmit(onSubmit)} className="space-y-6" noValidate>
             <div className="space-y-2">
               <Label htmlFor="project_name">
                 {t("onboarding.projectName", "프로젝트 이름")}
               </Label>
               <Input
                 id="project_name"
-                placeholder="my_perfume_project"
+                placeholder="my_ontology_project"
                 aria-invalid={Boolean(errors.project_name)}
                 {...register("project_name")}
               />
@@ -131,37 +350,27 @@ export default function OnboardingPage() {
                 </p>
               )}
               <p className="text-xs text-muted-foreground">
-                {t(
-                  "onboarding.projectNameHint",
-                  "영문, 숫자, _ , - 만 사용 (2~64자)",
-                )}
+                영문, 숫자, _, - 만 사용 (2~64자)
               </p>
             </div>
 
             <div className="space-y-2">
               <Label>{t("onboarding.domain", "도메인")}</Label>
               {isError && (
-                <Card className="border-destructive">
-                  <CardContent className="flex items-center justify-between gap-3 py-4">
-                    <div className="flex items-center gap-2 text-sm text-destructive">
-                      <AlertCircle className="h-4 w-4" />
-                      <span>{(error as Error).message}</span>
-                    </div>
-                    <Button
-                      variant="outline"
-                      size="sm"
-                      type="button"
-                      onClick={() => refetch()}
-                    >
-                      {t("common.retry", "다시 시도")}
-                    </Button>
-                  </CardContent>
-                </Card>
+                <div className="flex items-center justify-between gap-3 rounded-md border border-destructive px-4 py-3">
+                  <div className="flex items-center gap-2 text-sm text-destructive">
+                    <AlertCircle className="h-4 w-4" />
+                    <span>{(error as Error).message}</span>
+                  </div>
+                  <Button variant="outline" size="sm" type="button" onClick={() => refetch()}>
+                    {t("common.retry", "다시 시도")}
+                  </Button>
+                </div>
               )}
               {domainsLoading && (
                 <div className="grid grid-cols-1 gap-3 sm:grid-cols-2">
                   {Array.from({ length: 4 }).map((_, i) => (
-                    <Skeleton key={i} className="h-24" />
+                    <Skeleton key={i} className="h-28" />
                   ))}
                 </div>
               )}
@@ -170,43 +379,56 @@ export default function OnboardingPage() {
                   {domains.map((d) => {
                     const active = selectedDomain === d.domain;
                     return (
-                      <button
+                      <div
                         key={d.domain}
-                        type="button"
-                        onClick={() =>
-                          setValue("domain", d.domain, {
-                            shouldValidate: true,
-                          })
-                        }
                         className={cn(
-                          "rounded-lg border bg-card p-4 text-left transition-colors hover:bg-accent/40 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring",
+                          "rounded-lg border bg-card transition-colors",
                           active && "border-primary bg-accent/60",
                         )}
                       >
-                        <div className="mb-1 font-semibold capitalize">
-                          {d.domain}
+                        <div className="flex items-start gap-2 p-4">
+                          <button
+                            type="button"
+                            onClick={() =>
+                              setValue("domain", d.domain, {
+                                shouldValidate: true,
+                              })
+                            }
+                            className="min-w-0 flex-1 text-left focus-visible:outline-none"
+                          >
+                            <div className="mb-1 flex items-center gap-2">
+                              <span className="font-semibold capitalize">{d.domain}</span>
+                              {d.is_custom && (
+                                <span className="rounded border px-1.5 py-0.5 text-[10px] text-muted-foreground">
+                                  custom
+                                </span>
+                              )}
+                            </div>
+                            <div className="text-xs text-muted-foreground">
+                              엔티티 {d.entity_types.length}종 · 관계 {d.predicates.length}개 · 속성 {d.attribute_count}개
+                            </div>
+                            <div className="mt-2 line-clamp-2 text-xs text-muted-foreground/70">
+                              {d.entity_types.slice(0, 6).join(", ")}
+                              {d.entity_types.length > 6 && " ..."}
+                            </div>
+                          </button>
+                          <Button
+                            type="button"
+                            variant="ghost"
+                            size="icon"
+                            aria-label={`${d.domain} 편집`}
+                            onClick={() => setEditorState({ mode: "edit", domain: d })}
+                          >
+                            <Pencil className="h-4 w-4" />
+                          </Button>
                         </div>
-                        <div className="text-xs text-muted-foreground">
-                          {t("onboarding.domainSummary", {
-                            entities: d.entity_types.length,
-                            predicates: d.predicates.length,
-                            defaultValue:
-                              "엔티티 {{entities}}종 · 관계 {{predicates}}개",
-                          })}
-                        </div>
-                        <div className="mt-2 line-clamp-2 text-xs text-muted-foreground/70">
-                          {d.entity_types.slice(0, 5).join(", ")}
-                          {d.entity_types.length > 5 && " …"}
-                        </div>
-                      </button>
+                      </div>
                     );
                   })}
                 </div>
               )}
               {errors.domain && (
-                <p className="text-sm text-destructive">
-                  {errors.domain.message}
-                </p>
+                <p className="text-sm text-destructive">{errors.domain.message}</p>
               )}
             </div>
 
@@ -219,19 +441,20 @@ export default function OnboardingPage() {
               >
                 {t("common.cancel", "취소")}
               </Button>
-              <Button
-                type="submit"
-                disabled={isSubmitting || createProject.isPending}
-              >
-                {createProject.isPending && (
-                  <Loader2 className="h-4 w-4 animate-spin" />
-                )}
+              <Button type="submit" disabled={isSubmitting || createProject.isPending}>
+                {createProject.isPending && <Loader2 className="h-4 w-4 animate-spin" />}
                 {t("onboarding.submit", "프로젝트 만들기")}
               </Button>
             </div>
           </form>
         </CardContent>
       </Card>
+
+      <DomainEditorDialog
+        state={editorState}
+        onClose={() => setEditorState(null)}
+        onSelect={(domain) => setValue("domain", domain, { shouldValidate: true })}
+      />
     </div>
   );
 }
diff --git a/ontology_platform/web/frontend/src/pages/OntologyEditorPage.tsx b/ontology_platform/web/frontend/src/pages/OntologyEditorPage.tsx
index 146abb9..29f5e6c 100644
--- a/ontology_platform/web/frontend/src/pages/OntologyEditorPage.tsx
+++ b/ontology_platform/web/frontend/src/pages/OntologyEditorPage.tsx
@@ -1,15 +1,12 @@
 import { useMemo, useState } from "react";
-import { useNavigate, useParams } from "react-router-dom";
+import { useParams } from "react-router-dom";
 import { useTranslation } from "react-i18next";
 import { useForm } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { z } from "zod";
 import { toast } from "sonner";
 import {
-  AlertCircle,
-  ArrowLeft,
   FileJson,
-  Link2,
   Loader2,
   Network,
   Plus,
@@ -27,9 +24,21 @@ import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Select } from "@/components/ui/select";
 import { Textarea } from "@/components/ui/textarea";
-import { Skeleton } from "@/components/ui/skeleton";
 import { Badge } from "@/components/ui/badge";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { DataTable, type ColumnDef } from "@/components/ui/data-table";
+import { Drawer } from "@/components/ui/drawer";
+import { EmptyState } from "@/components/ui/empty-state";
+import { ErrorState } from "@/components/ui/error-state";
+import { Tooltip } from "@/components/ui/tooltip";
+import {
+  FilterPanel,
+  FilterSearch,
+  FilterSelect,
+  FilterChips,
+  type ActiveChip,
+} from "@/components/ui/filter-panel";
+import { PageHeader } from "@/components/layout/PageHeader";
 import { useProject } from "@/hooks/useProjects";
 import { useOntology } from "@/hooks/useDomains";
 import {
@@ -43,6 +52,13 @@ import {
   useCreateClaim,
   useDeleteClaim,
 } from "@/hooks/useClaims";
+import { Entity } from "@/lib/api/entities";
+import { Claim } from "@/lib/api/claims";
+import { humanizeValue } from "@/lib/display";
+
+/* ============================================================
+ * Schemas
+ * ========================================================== */
 
 const entitySchema = z.object({
   entity_type: z.string().min(1, "타입을 선택하세요"),
@@ -61,19 +77,33 @@ const claimSchema = z.object({
 });
 type ClaimFormValues = z.infer<typeof claimSchema>;
 
+/* ============================================================
+ * Page
+ * ========================================================== */
+
 export default function OntologyEditorPage() {
-  const navigate = useNavigate();
   const { projectId } = useParams<{ projectId: string }>();
   const { t } = useTranslation();
   const projectName = projectId ?? "";
-  const [tab, setTab] = useState<"entities" | "claims" | "bulk">("entities");
 
-  const { data: project, isLoading: projectLoading, isError, error, refetch } =
-    useProject(projectName);
+  const [tab, setTab] = useState<"entities" | "claims" | "bulk">("entities");
+  const [addEntityOpen, setAddEntityOpen] = useState(false);
+  const [addClaimOpen, setAddClaimOpen] = useState(false);
+  const [entitySearch, setEntitySearch] = useState("");
+  const [entityTypeFilter, setEntityTypeFilter] = useState("");
+  const [claimSearch, setClaimSearch] = useState("");
+
+  const {
+    data: project,
+    isLoading: projectLoading,
+    isError,
+    error,
+    refetch,
+  } = useProject(projectName);
   const { data: ontology } = useOntology(project?.domain);
 
   const entities = useEntities(projectName);
-  const claims = useClaims(projectName, { includeCandidates: true });
+  const claims = useClaims(projectName, { includeCandidates: true, limit: 500 });
 
   const createEntity = useCreateEntity(projectName);
   const bulkCreate = useBulkCreateEntities(projectName);
@@ -91,7 +121,8 @@ export default function OntologyEditorPage() {
     return ["hasAttribute", "relatedTo", "sameAs"];
   }, [ontology]);
 
-  // ── Entity form ───────────────────────────────────────────────
+  /* --------------------- Forms --------------------- */
+
   const entityForm = useForm<EntityFormValues>({
     resolver: zodResolver(entitySchema),
     defaultValues: { entity_type: "", name: "" },
@@ -109,6 +140,7 @@ export default function OntologyEditorPage() {
         }),
       );
       entityForm.reset({ entity_type: values.entity_type, name: "" });
+      setAddEntityOpen(false);
     } catch (e) {
       toast.error(
         t("editor.entityAddFailed", "추가 실패: {{msg}}", {
@@ -118,7 +150,6 @@ export default function OntologyEditorPage() {
     }
   };
 
-  // ── Claim form ────────────────────────────────────────────────
   const claimForm = useForm<ClaimFormValues>({
     resolver: zodResolver(claimSchema),
     defaultValues: {
@@ -151,6 +182,7 @@ export default function OntologyEditorPage() {
         object_entity_id: null,
         object_value: "",
       });
+      setAddClaimOpen(false);
     } catch (e) {
       toast.error(
         t("editor.claimAddFailed", "추가 실패: {{msg}}", {
@@ -160,7 +192,8 @@ export default function OntologyEditorPage() {
     }
   };
 
-  // ── Bulk JSON form ────────────────────────────────────────────
+  /* --------------------- Bulk JSON --------------------- */
+
   const [bulkText, setBulkText] = useState(
     JSON.stringify(
       {
@@ -187,26 +220,28 @@ export default function OntologyEditorPage() {
       if (!list || list.length === 0) {
         throw new Error("최상위에 entities 배열이 있어야 합니다");
       }
-      const normalized = list.map((item: Record<string, unknown>, idx: number) => {
-        if (
-          typeof item !== "object" ||
-          item === null ||
-          typeof item.entity_type !== "string" ||
-          typeof item.name !== "string"
-        ) {
-          throw new Error(
-            `항목 [${idx}]에 entity_type/name 문자열이 필요합니다`,
-          );
-        }
-        return {
-          entity_type: item.entity_type,
-          name: item.name,
-          metadata:
-            typeof item.metadata === "object" && item.metadata !== null
-              ? (item.metadata as Record<string, unknown>)
-              : {},
-        };
-      });
+      const normalized = list.map(
+        (item: Record<string, unknown>, idx: number) => {
+          if (
+            typeof item !== "object" ||
+            item === null ||
+            typeof item.entity_type !== "string" ||
+            typeof item.name !== "string"
+          ) {
+            throw new Error(
+              `항목 [${idx}]에 entity_type/name 문자열이 필요합니다`,
+            );
+          }
+          return {
+            entity_type: item.entity_type,
+            name: item.name,
+            metadata:
+              typeof item.metadata === "object" && item.metadata !== null
+                ? (item.metadata as Record<string, unknown>)
+                : {},
+          };
+        },
+      );
       const res = await bulkCreate.mutateAsync({ entities: normalized });
       toast.success(
         t("editor.bulkAdded", "{{count}}개 엔티티가 추가되었습니다", {
@@ -218,471 +253,666 @@ export default function OntologyEditorPage() {
     }
   };
 
-  // ── Render ────────────────────────────────────────────────────
-  return (
-    <div className="mx-auto max-w-7xl px-6 py-10">
-      <div className="mb-6 flex items-center gap-3">
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => navigate(`/sources/${projectName}`)}
-          aria-label={t("common.back", "이전")}
-        >
-          <ArrowLeft className="h-4 w-4" />
-        </Button>
-        <div className="flex-1">
-          <h1 className="flex items-center gap-2 text-2xl font-bold tracking-tight">
-            <Network className="h-6 w-6 text-primary" />
-            {t("editor.title", "온톨로지 직접 편집")}
-          </h1>
-          {project && (
-            <p className="text-sm text-muted-foreground">
-              {project.name}
-              <span className="capitalize text-muted-foreground/70">
-                {" "}
-                · {project.domain}
-              </span>
-            </p>
-          )}
+  /* --------------------- Filtered data --------------------- */
+
+  const filteredEntities = useMemo(() => {
+    const q = entitySearch.trim().toLowerCase();
+    return (entities.data ?? []).filter((e) => {
+      if (entityTypeFilter && e.type !== entityTypeFilter) return false;
+      if (!q) return true;
+      return (
+        e.name.toLowerCase().includes(q) || e.type.toLowerCase().includes(q)
+      );
+    });
+  }, [entities.data, entitySearch, entityTypeFilter]);
+
+  const entityTypeCounts = useMemo(() => {
+    const counts = new Map<string, number>();
+    (entities.data ?? []).forEach((e) =>
+      counts.set(e.type, (counts.get(e.type) ?? 0) + 1),
+    );
+    return counts;
+  }, [entities.data]);
+
+  const filteredClaims = useMemo(() => {
+    const q = claimSearch.trim().toLowerCase();
+    return (claims.data ?? []).filter((c) => {
+      if (!q) return true;
+      return [c.subject, c.predicate, c.object, c.object_value, c.source]
+        .map((v) => humanizeValue(v, "").toLowerCase())
+        .some((v) => v.includes(q));
+    });
+  }, [claims.data, claimSearch]);
+
+  /* --------------------- Entity table --------------------- */
+
+  const entityColumns: ColumnDef<Entity, any>[] = [
+    {
+      id: "type",
+      header: "Type",
+      accessorFn: (row) => row.type,
+      cell: ({ row }) => <Badge variant="outline">{row.original.type}</Badge>,
+      size: 140,
+      enablePinning: true,
+    },
+    {
+      id: "name",
+      header: "Name",
+      accessorFn: (row) => row.name,
+      cell: ({ row }) => (
+        <span className="font-medium text-foreground">{row.original.name}</span>
+      ),
+      size: 360,
+    },
+    {
+      id: "id",
+      header: "ID",
+      accessorFn: (row) => row.id,
+      cell: ({ row }) => (
+        <span className="font-mono text-2xs text-muted-foreground">
+          #{row.original.id}
+        </span>
+      ),
+      size: 100,
+      meta: { align: "right" },
+    },
+    {
+      id: "actions",
+      header: "",
+      enableSorting: false,
+      enableHiding: false,
+      enableResizing: false,
+      cell: ({ row }) => (
+        <div className="flex justify-end">
+          <Tooltip content="Delete entity" shortcut="Del">
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={(e) => {
+                e.stopPropagation();
+                if (
+                  confirm(
+                    t(
+                      "editor.confirmDeleteEntity",
+                      "엔티티 '{{name}}'을 삭제하시겠습니까?",
+                      { name: row.original.name },
+                    ),
+                  )
+                ) {
+                  deleteEntity.mutate(row.original.id);
+                }
+              }}
+              disabled={deleteEntity.isPending}
+              className="h-7 w-7"
+            >
+              <Trash2 className="h-3.5 w-3.5 text-danger" />
+            </Button>
+          </Tooltip>
         </div>
+      ),
+      size: 60,
+      meta: { align: "right" },
+    },
+  ];
+
+  /* --------------------- Claim table --------------------- */
+
+  const claimColumns: ColumnDef<Claim, any>[] = [
+    {
+      id: "subject",
+      header: "Subject",
+      accessorFn: (row) => humanizeValue(row.subject),
+      cell: ({ row }) => (
+        <span className="line-clamp-2 break-words font-medium text-foreground">
+          {humanizeValue(row.original.subject)}
+        </span>
+      ),
+      size: 200,
+      enablePinning: true,
+    },
+    {
+      id: "predicate",
+      header: "Predicate",
+      accessorFn: (row) => row.predicate,
+      cell: ({ row }) => (
+        <Badge variant="secondary" className="font-mono">
+          {row.original.predicate}
+        </Badge>
+      ),
+      size: 160,
+    },
+    {
+      id: "object",
+      header: "Object",
+      accessorFn: (row) =>
+        humanizeValue(row.object ?? row.object_value),
+      cell: ({ row }) => (
+        <span className="line-clamp-2 break-words text-foreground">
+          {humanizeValue(row.original.object ?? row.original.object_value)}
+        </span>
+      ),
+      size: 260,
+    },
+    {
+      id: "source",
+      header: "Source",
+      accessorFn: (row) => row.source ?? "",
+      cell: ({ row }) => (
+        <span className="text-xs text-muted-foreground">
+          {humanizeValue(row.original.source)}
+        </span>
+      ),
+      size: 120,
+    },
+    {
+      id: "confidence",
+      header: "Confidence",
+      accessorFn: (row) => row.confidence ?? 0,
+      cell: ({ row }) =>
+        typeof row.original.confidence === "number" ? (
+          <span className="text-xs tabular-nums text-foreground">
+            {(row.original.confidence * 100).toFixed(0)}%
+          </span>
+        ) : (
+          <span className="text-xs text-muted-foreground/60">—</span>
+        ),
+      size: 110,
+      meta: { align: "right" },
+    },
+    {
+      id: "status",
+      header: "Status",
+      accessorFn: (row) => row.status ?? "",
+      cell: ({ row }) =>
+        row.original.status ? (
+          <Badge variant="outline">{row.original.status}</Badge>
+        ) : (
+          <span className="text-xs text-muted-foreground/60">—</span>
+        ),
+      size: 130,
+    },
+    {
+      id: "actions",
+      header: "",
+      enableSorting: false,
+      enableHiding: false,
+      enableResizing: false,
+      cell: ({ row }) => (
+        <div className="flex justify-end">
+          <Tooltip content="Delete claim">
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={(e) => {
+                e.stopPropagation();
+                if (
+                  confirm(
+                    t(
+                      "editor.confirmDeleteClaim",
+                      "클레임을 삭제하시겠습니까?",
+                    ),
+                  )
+                ) {
+                  deleteClaim.mutate(row.original.id);
+                }
+              }}
+              className="h-7 w-7"
+            >
+              <Trash2 className="h-3.5 w-3.5 text-danger" />
+            </Button>
+          </Tooltip>
+        </div>
+      ),
+      size: 60,
+      meta: { align: "right" },
+    },
+  ];
+
+  /* --------------------- Chips --------------------- */
+
+  const entityChips: ActiveChip[] = [];
+  if (entitySearch)
+    entityChips.push({
+      id: "search",
+      label: "Search",
+      value: `"${entitySearch}"`,
+      onClear: () => setEntitySearch(""),
+    });
+  if (entityTypeFilter)
+    entityChips.push({
+      id: "type",
+      label: "Type",
+      value: entityTypeFilter,
+      onClear: () => setEntityTypeFilter(""),
+    });
+
+  /* --------------------- Render --------------------- */
+
+  return (
+    <>
+      <PageHeader
+        icon={Network}
+        breadcrumbs={[
+          { label: "Dashboard", to: "/" },
+          { label: projectName, to: `/sources/${projectName}` },
+          { label: t("editor.title", "Entity Manager") },
+        ]}
+        title={t("editor.title", "온톨로지 직접 편집")}
+        description={
+          project &&
+          `${project.name} · ${project.domain} · ${
+            entities.data?.length ?? 0
+          } entities · ${claims.data?.length ?? 0} claims`
+        }
+        actions={
+          <>
+            {tab === "entities" && (
+              <Button onClick={() => setAddEntityOpen(true)}>
+                <Plus className="h-4 w-4" />
+                {t("editor.addEntity", "엔티티 추가")}
+              </Button>
+            )}
+            {tab === "claims" && (
+              <Button onClick={() => setAddClaimOpen(true)}>
+                <Plus className="h-4 w-4" />
+                {t("editor.addClaim", "클레임 추가")}
+              </Button>
+            )}
+          </>
+        }
+      />
+
+      <div className="mx-auto max-w-7xl px-6 py-6">
+        {isError && (
+          <ErrorState
+            className="mb-4"
+            inline
+            severity="error"
+            title="Failed to load project"
+            description={error as Error}
+            onRetry={() => refetch()}
+          />
+        )}
+
+        <Tabs value={tab} onValueChange={(v) => setTab(v as typeof tab)}>
+          <TabsList>
+            <TabsTrigger value="entities">
+              {t("editor.entitiesTab", "엔티티")} · {entities.data?.length ?? 0}
+            </TabsTrigger>
+            <TabsTrigger value="claims">
+              {t("editor.claimsTab", "클레임")} · {claims.data?.length ?? 0}
+            </TabsTrigger>
+            <TabsTrigger value="bulk">
+              <FileJson className="mr-1 h-4 w-4" />
+              {t("editor.bulkTab", "JSON 일괄 입력")}
+            </TabsTrigger>
+          </TabsList>
+
+          {/* ── Entities Tab ──────────────────────────────────── */}
+          <TabsContent value="entities" className="mt-4 space-y-3">
+            <FilterPanel
+              chips={
+                entityChips.length > 0 ? <FilterChips chips={entityChips} /> : undefined
+              }
+              onClearAll={
+                entityChips.length > 0
+                  ? () => {
+                      setEntitySearch("");
+                      setEntityTypeFilter("");
+                    }
+                  : undefined
+              }
+            >
+              <FilterSearch
+                value={entitySearch}
+                onChange={setEntitySearch}
+                placeholder="Search entities by name or type…"
+              />
+              <FilterSelect
+                label="Type"
+                value={entityTypeFilter}
+                onChange={setEntityTypeFilter}
+                placeholder="All types"
+                options={entityTypeOptions.map((t) => ({
+                  value: t,
+                  label: t,
+                  hint: entityTypeCounts.get(t) ?? 0,
+                }))}
+              />
+            </FilterPanel>
+
+            <DataTable<Entity>
+              tableId="entities"
+              columns={entityColumns}
+              data={filteredEntities}
+              getRowId={(row) => String(row.id)}
+              loading={entities.isLoading}
+              loadingRows={8}
+              height={620}
+              empty={
+                <EmptyState
+                  icon={Network}
+                  title={t("editor.entitiesEmpty", "아직 등록된 엔티티가 없습니다")}
+                  description="첫 엔티티를 추가해 온톨로지를 구축하세요."
+                  primaryAction={
+                    <Button onClick={() => setAddEntityOpen(true)}>
+                      <Plus className="h-4 w-4" />
+                      {t("editor.addEntity", "엔티티 추가")}
+                    </Button>
+                  }
+                />
+              }
+            />
+          </TabsContent>
+
+          {/* ── Claims Tab ────────────────────────────────────── */}
+          <TabsContent value="claims" className="mt-4 space-y-3">
+            <FilterPanel
+              chips={
+                claimSearch ? (
+                  <FilterChips
+                    chips={[
+                      {
+                        id: "search",
+                        label: "Search",
+                        value: `"${claimSearch}"`,
+                        onClear: () => setClaimSearch(""),
+                      },
+                    ]}
+                  />
+                ) : undefined
+              }
+              onClearAll={claimSearch ? () => setClaimSearch("") : undefined}
+            >
+              <FilterSearch
+                value={claimSearch}
+                onChange={setClaimSearch}
+                placeholder="Search subject, predicate, object…"
+              />
+            </FilterPanel>
+
+            <DataTable<Claim>
+              tableId="editor-claims"
+              columns={claimColumns}
+              data={filteredClaims}
+              getRowId={(row) => row.id}
+              loading={claims.isLoading}
+              loadingRows={8}
+              height={620}
+              empty={
+                <EmptyState
+                  icon={Plus}
+                  title={t("editor.claimsEmpty", "아직 등록된 클레임이 없습니다")}
+                  description="주어·술어·목적어를 입력해 첫 클레임을 만드세요."
+                  primaryAction={
+                    <Button onClick={() => setAddClaimOpen(true)}>
+                      <Plus className="h-4 w-4" />
+                      {t("editor.addClaim", "클레임 추가")}
+                    </Button>
+                  }
+                />
+              }
+            />
+          </TabsContent>
+
+          {/* ── Bulk Tab ──────────────────────────────────────── */}
+          <TabsContent value="bulk" className="mt-4">
+            <Card>
+              <CardHeader>
+                <CardTitle>{t("editor.bulkTitle", "JSON 일괄 입력")}</CardTitle>
+                <CardDescription>
+                  {t(
+                    "editor.bulkDesc",
+                    "{ entities: [{ entity_type, name, metadata? }] } 형태의 JSON",
+                  )}
+                </CardDescription>
+              </CardHeader>
+              <CardContent className="space-y-3">
+                <Textarea
+                  value={bulkText}
+                  onChange={(e) => setBulkText(e.target.value)}
+                  rows={14}
+                  className="font-mono text-xs"
+                />
+                {bulkError && (
+                  <ErrorState
+                    inline
+                    severity="error"
+                    title="JSON parse error"
+                    description={bulkError}
+                  />
+                )}
+                <div className="flex justify-end">
+                  <Button
+                    onClick={onBulkSubmit}
+                    disabled={bulkCreate.isPending || projectLoading}
+                  >
+                    {bulkCreate.isPending ? (
+                      <Loader2 className="h-4 w-4 animate-spin" />
+                    ) : (
+                      <FileJson className="h-4 w-4" />
+                    )}
+                    {t("editor.bulkSubmit", "일괄 추가")}
+                  </Button>
+                </div>
+              </CardContent>
+            </Card>
+          </TabsContent>
+        </Tabs>
       </div>
 
-      {isError && (
-        <Card className="mb-6 border-destructive">
-          <CardContent className="flex items-center justify-between gap-3 py-4">
-            <div className="flex items-center gap-2 text-sm text-destructive">
-              <AlertCircle className="h-4 w-4" />
-              <span>{(error as Error).message}</span>
-            </div>
-            <Button
-              variant="outline"
-              size="sm"
-              type="button"
-              onClick={() => refetch()}
-            >
-              {t("common.retry", "다시 시도")}
+      {/* ── Add Entity Drawer ─────────────────────────────────── */}
+      <Drawer
+        open={addEntityOpen}
+        onOpenChange={setAddEntityOpen}
+        size="md"
+        title={t("editor.addEntity", "엔티티 추가")}
+        description={t(
+          "editor.addEntityDesc",
+          "온톨로지 도메인의 entity_types 중에서 선택",
+        )}
+        footer={
+          <>
+            <Button variant="ghost" onClick={() => setAddEntityOpen(false)}>
+              {t("common.cancel", "취소")}
             </Button>
-          </CardContent>
-        </Card>
-      )}
-
-      <Tabs value={tab} onValueChange={(v) => setTab(v as typeof tab)}>
-        <TabsList>
-          <TabsTrigger value="entities">
-            {t("editor.entitiesTab", "엔티티")} ({entities.data?.length ?? 0})
-          </TabsTrigger>
-          <TabsTrigger value="claims">
-            <Link2 className="mr-1 h-4 w-4" />
-            {t("editor.claimsTab", "클레임")} ({claims.data?.length ?? 0})
-          </TabsTrigger>
-          <TabsTrigger value="bulk">
-            <FileJson className="mr-1 h-4 w-4" />
-            {t("editor.bulkTab", "JSON 일괄 입력")}
-          </TabsTrigger>
-        </TabsList>
-
-        {/* ── Entities Tab ─────────────────────────────────────── */}
-        <TabsContent value="entities">
-          <div className="grid gap-6 lg:grid-cols-[380px_1fr]">
-            <Card>
-              <CardHeader>
-                <CardTitle>{t("editor.addEntity", "엔티티 추가")}</CardTitle>
-                <CardDescription>
-                  {t(
-                    "editor.addEntityDesc",
-                    "온톨로지 도메인의 entity_types 중에서 선택",
-                  )}
-                </CardDescription>
-              </CardHeader>
-              <CardContent>
-                <form
-                  onSubmit={entityForm.handleSubmit(onCreateEntity)}
-                  className="space-y-3"
-                  noValidate
-                >
-                  <div className="space-y-1.5">
-                    <Label>{t("editor.entityType", "타입")}</Label>
-                    <Select {...entityForm.register("entity_type")}>
-                      <option value="">
-                        {t("editor.pickType", "타입 선택...")}
-                      </option>
-                      {entityTypeOptions.map((opt) => (
-                        <option key={opt} value={opt}>
-                          {opt}
-                        </option>
-                      ))}
-                    </Select>
-                    {entityForm.formState.errors.entity_type && (
-                      <p className="text-xs text-destructive">
-                        {entityForm.formState.errors.entity_type.message}
-                      </p>
-                    )}
-                  </div>
-                  <div className="space-y-1.5">
-                    <Label>{t("editor.entityName", "이름")}</Label>
-                    <Input
-                      placeholder="Chanel No.5"
-                      {...entityForm.register("name")}
-                    />
-                    {entityForm.formState.errors.name && (
-                      <p className="text-xs text-destructive">
-                        {entityForm.formState.errors.name.message}
-                      </p>
-                    )}
-                  </div>
-                  <Button
-                    type="submit"
-                    className="w-full"
-                    disabled={createEntity.isPending}
-                  >
-                    {createEntity.isPending ? (
-                      <Loader2 className="h-4 w-4 animate-spin" />
-                    ) : (
-                      <Plus className="h-4 w-4" />
-                    )}
-                    {t("editor.add", "추가")}
-                  </Button>
-                </form>
-              </CardContent>
-            </Card>
-
-            <Card>
-              <CardHeader>
-                <CardTitle>
-                  {t("editor.entitiesList", "엔티티 목록")}
-                </CardTitle>
-                <CardDescription>
-                  {entities.data
-                    ? t("editor.entityCount", "{{count}}개", {
-                        count: entities.data.length,
-                      })
-                    : t("dashboard.loadFailed", "")}
-                </CardDescription>
-              </CardHeader>
-              <CardContent>
-                {entities.isLoading && (
-                  <div className="space-y-2">
-                    {Array.from({ length: 4 }).map((_, i) => (
-                      <Skeleton key={i} className="h-10" />
-                    ))}
-                  </div>
-                )}
-                {entities.data && entities.data.length === 0 && (
-                  <p className="py-6 text-center text-sm text-muted-foreground">
-                    {t("editor.entitiesEmpty", "아직 등록된 엔티티가 없습니다")}
-                  </p>
-                )}
-                {entities.data && entities.data.length > 0 && (
-                  <ul className="max-h-[600px] divide-y overflow-y-auto">
-                    {entities.data.map((e) => (
-                      <li
-                        key={e.id}
-                        className="flex items-center justify-between gap-3 py-2 text-sm"
-                      >
-                        <div className="min-w-0 flex-1">
-                          <div className="flex items-center gap-2">
-                            <Badge variant="outline">{e.type}</Badge>
-                            <span className="truncate font-medium">
-                              {e.name}
-                            </span>
-                          </div>
-                        </div>
-                        <Button
-                          variant="ghost"
-                          size="icon"
-                          onClick={() => {
-                            if (
-                              confirm(
-                                t(
-                                  "editor.confirmDeleteEntity",
-                                  "엔티티 '{{name}}'을 삭제하시겠습니까?",
-                                  { name: e.name },
-                                ),
-                              )
-                            ) {
-                              deleteEntity.mutate(e.id);
-                            }
-                          }}
-                          disabled={deleteEntity.isPending}
-                        >
-                          <Trash2 className="h-4 w-4 text-destructive" />
-                        </Button>
-                      </li>
-                    ))}
-                  </ul>
-                )}
-              </CardContent>
-            </Card>
-          </div>
-        </TabsContent>
-
-        {/* ── Claims Tab ───────────────────────────────────────── */}
-        <TabsContent value="claims">
-          <div className="grid gap-6 lg:grid-cols-[420px_1fr]">
-            <Card>
-              <CardHeader>
-                <CardTitle>{t("editor.addClaim", "클레임 추가")}</CardTitle>
-                <CardDescription>
-                  {t(
-                    "editor.addClaimDesc",
-                    "주어-술어-목적어 형태로 직접 입력",
-                  )}
-                </CardDescription>
-              </CardHeader>
-              <CardContent>
-                <form
-                  onSubmit={claimForm.handleSubmit(onCreateClaim)}
-                  className="space-y-3"
-                  noValidate
-                >
-                  <div className="space-y-1.5">
-                    <Label>{t("editor.source", "소스")}</Label>
-                    <Select {...claimForm.register("source_name")}>
-                      <option value="">
-                        {t("editor.pickSource", "소스 선택...")}
-                      </option>
-                      {sources.map((s) => (
-                        <option key={s.id} value={s.name}>
-                          {s.name}
-                        </option>
-                      ))}
-                    </Select>
-                    {claimForm.formState.errors.source_name && (
-                      <p className="text-xs text-destructive">
-                        {claimForm.formState.errors.source_name.message}
-                      </p>
-                    )}
-                  </div>
-
-                  <div className="space-y-1.5">
-                    <Label>{t("editor.subject", "주어 (Subject)")}</Label>
-                    <Select
-                      {...claimForm.register("subject_entity_id", {
-                        valueAsNumber: true,
-                      })}
-                    >
-                      <option value={0}>
-                        {t("editor.pickSubject", "엔티티 선택...")}
-                      </option>
-                      {entities.data?.map((e) => (
-                        <option key={e.id} value={e.id}>
-                          [{e.type}] {e.name}
-                        </option>
-                      ))}
-                    </Select>
-                    {claimForm.formState.errors.subject_entity_id && (
-                      <p className="text-xs text-destructive">
-                        {claimForm.formState.errors.subject_entity_id.message}
-                      </p>
-                    )}
-                  </div>
-
-                  <div className="space-y-1.5">
-                    <Label>{t("editor.predicate", "술어 (Predicate)")}</Label>
-                    <Select {...claimForm.register("predicate")}>
-                      <option value="">
-                        {t("editor.pickPredicate", "술어 선택...")}
-                      </option>
-                      {predicateOptions.map((p) => (
-                        <option key={p} value={p}>
-                          {p}
-                        </option>
-                      ))}
-                    </Select>
-                  </div>
-
-                  <div className="space-y-1.5">
-                    <Label>{t("editor.objectKind", "목적어 유형")}</Label>
-                    <Select {...claimForm.register("object_kind")}>
-                      <option value="entity">
-                        {t("editor.objectEntity", "다른 엔티티")}
-                      </option>
-                      <option value="value">
-                        {t("editor.objectValue", "리터럴 값")}
-                      </option>
-                    </Select>
-                  </div>
-
-                  {objectKind === "entity" ? (
-                    <div className="space-y-1.5">
-                      <Label>{t("editor.objectEntity", "목적 엔티티")}</Label>
-                      <Select
-                        {...claimForm.register("object_entity_id", {
-                          valueAsNumber: true,
-                          setValueAs: (v) =>
-                            v === "" || v === null || v === undefined
-                              ? null
-                              : Number(v),
-                        })}
-                      >
-                        <option value="">
-                          {t("editor.pickObject", "엔티티 선택...")}
-                        </option>
-                        {entities.data?.map((e) => (
-                          <option key={e.id} value={e.id}>
-                            [{e.type}] {e.name}
-                          </option>
-                        ))}
-                      </Select>
-                    </div>
-                  ) : (
-                    <div className="space-y-1.5">
-                      <Label>{t("editor.objectValue", "값")}</Label>
-                      <Input
-                        placeholder="2024-01-15 또는 임의 문자열"
-                        {...claimForm.register("object_value")}
-                      />
-                    </div>
-                  )}
-
-                  <div className="space-y-1.5">
-                    <Label>{t("editor.confidence", "신뢰도")}</Label>
-                    <Input
-                      type="number"
-                      step="0.05"
-                      min={0}
-                      max={1}
-                      {...claimForm.register("confidence", {
-                        valueAsNumber: true,
-                      })}
-                    />
-                  </div>
-
-                  <Button
-                    type="submit"
-                    className="w-full"
-                    disabled={createClaim.isPending}
-                  >
-                    {createClaim.isPending ? (
-                      <Loader2 className="h-4 w-4 animate-spin" />
-                    ) : (
-                      <Plus className="h-4 w-4" />
-                    )}
-                    {t("editor.add", "추가")}
-                  </Button>
-                </form>
-              </CardContent>
-            </Card>
-
-            <Card>
-              <CardHeader>
-                <CardTitle>{t("editor.claimsList", "클레임 목록")}</CardTitle>
-                <CardDescription>
-                  {claims.data &&
-                    t("editor.claimCount", "{{count}}개", {
-                      count: claims.data.length,
-                    })}
-                </CardDescription>
-              </CardHeader>
-              <CardContent>
-                {claims.isLoading && (
-                  <div className="space-y-2">
-                    {Array.from({ length: 3 }).map((_, i) => (
-                      <Skeleton key={i} className="h-12" />
-                    ))}
-                  </div>
-                )}
-                {claims.data && claims.data.length === 0 && (
-                  <p className="py-6 text-center text-sm text-muted-foreground">
-                    {t("editor.claimsEmpty", "아직 등록된 클레임이 없습니다")}
-                  </p>
-                )}
-                {claims.data && claims.data.length > 0 && (
-                  <ul className="max-h-[600px] divide-y overflow-y-auto">
-                    {claims.data.map((c) => (
-                      <li
-                        key={c.id}
-                        className="flex items-start justify-between gap-3 py-3 text-sm"
-                      >
-                        <div className="min-w-0 flex-1">
-                          <div className="flex flex-wrap items-center gap-1.5">
-                            <span className="font-medium">
-                              {c.subject ?? "?"}
-                            </span>
-                            <Badge variant="secondary">{c.predicate}</Badge>
-                            <span className="font-medium">
-                              {c.object ?? String(c.object_value ?? "—")}
-                            </span>
-                          </div>
-                          <div className="mt-1 flex flex-wrap gap-2 text-xs text-muted-foreground">
-                            <span>
-                              {t("editor.source", "소스")}: {c.source ?? "—"}
-                            </span>
-                            {typeof c.confidence === "number" && (
-                              <span>
-                                {t("editor.confidence", "신뢰도")}:{" "}
-                                {c.confidence.toFixed(2)}
-                              </span>
-                            )}
-                            {c.status && (
-                              <Badge variant="outline">{c.status}</Badge>
-                            )}
-                          </div>
-                        </div>
-                        <Button
-                          variant="ghost"
-                          size="icon"
-                          onClick={() => {
-                            if (
-                              confirm(
-                                t(
-                                  "editor.confirmDeleteClaim",
-                                  "클레임을 삭제하시겠습니까?",
-                                ),
-                              )
-                            ) {
-                              deleteClaim.mutate(c.id);
-                            }
-                          }}
-                        >
-                          <Trash2 className="h-4 w-4 text-destructive" />
-                        </Button>
-                      </li>
-                    ))}
-                  </ul>
-                )}
-              </CardContent>
-            </Card>
-          </div>
-        </TabsContent>
-
-        {/* ── Bulk Tab ─────────────────────────────────────────── */}
-        <TabsContent value="bulk">
-          <Card>
-            <CardHeader>
-              <CardTitle>{t("editor.bulkTitle", "JSON 일괄 입력")}</CardTitle>
-              <CardDescription>
-                {t(
-                  "editor.bulkDesc",
-                  "{ entities: [{ entity_type, name, metadata? }] } 형태의 JSON",
-                )}
-              </CardDescription>
-            </CardHeader>
-            <CardContent className="space-y-3">
-              <Textarea
-                value={bulkText}
-                onChange={(e) => setBulkText(e.target.value)}
-                rows={12}
-                className="font-mono text-xs"
-              />
-              {bulkError && (
-                <p className="text-sm text-destructive">{bulkError}</p>
+            <Button
+              type="submit"
+              form="add-entity-form"
+              disabled={createEntity.isPending}
+            >
+              {createEntity.isPending ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Plus className="h-4 w-4" />
               )}
-              <Button
-                onClick={onBulkSubmit}
-                disabled={bulkCreate.isPending || projectLoading}
+              {t("editor.add", "추가")}
+            </Button>
+          </>
+        }
+      >
+        <form
+          id="add-entity-form"
+          onSubmit={entityForm.handleSubmit(onCreateEntity)}
+          className="space-y-4"
+          noValidate
+        >
+          <div className="space-y-1.5">
+            <Label>{t("editor.entityType", "타입")}</Label>
+            <Select {...entityForm.register("entity_type")}>
+              <option value="">{t("editor.pickType", "타입 선택...")}</option>
+              {entityTypeOptions.map((opt) => (
+                <option key={opt} value={opt}>
+                  {opt}
+                </option>
+              ))}
+            </Select>
+            {entityForm.formState.errors.entity_type && (
+              <p className="text-xs text-danger">
+                {entityForm.formState.errors.entity_type.message}
+              </p>
+            )}
+          </div>
+          <div className="space-y-1.5">
+            <Label>{t("editor.entityName", "이름")}</Label>
+            <Input
+              placeholder="Chanel No.5"
+              autoFocus
+              {...entityForm.register("name")}
+            />
+            {entityForm.formState.errors.name && (
+              <p className="text-xs text-danger">
+                {entityForm.formState.errors.name.message}
+              </p>
+            )}
+          </div>
+        </form>
+      </Drawer>
+
+      {/* ── Add Claim Drawer ──────────────────────────────────── */}
+      <Drawer
+        open={addClaimOpen}
+        onOpenChange={setAddClaimOpen}
+        size="md"
+        title={t("editor.addClaim", "클레임 추가")}
+        description={t(
+          "editor.addClaimDesc",
+          "주어-술어-목적어 형태로 직접 입력",
+        )}
+        footer={
+          <>
+            <Button variant="ghost" onClick={() => setAddClaimOpen(false)}>
+              {t("common.cancel", "취소")}
+            </Button>
+            <Button
+              type="submit"
+              form="add-claim-form"
+              disabled={createClaim.isPending}
+            >
+              {createClaim.isPending ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Plus className="h-4 w-4" />
+              )}
+              {t("editor.add", "추가")}
+            </Button>
+          </>
+        }
+      >
+        <form
+          id="add-claim-form"
+          onSubmit={claimForm.handleSubmit(onCreateClaim)}
+          className="space-y-4"
+          noValidate
+        >
+          <div className="space-y-1.5">
+            <Label>{t("editor.source", "소스")}</Label>
+            <Select {...claimForm.register("source_name")}>
+              <option value="">{t("editor.pickSource", "소스 선택...")}</option>
+              {sources.map((s) => (
+                <option key={s.id} value={s.name}>
+                  {s.name}
+                </option>
+              ))}
+            </Select>
+            {claimForm.formState.errors.source_name && (
+              <p className="text-xs text-danger">
+                {claimForm.formState.errors.source_name.message}
+              </p>
+            )}
+          </div>
+
+          <div className="space-y-1.5">
+            <Label>{t("editor.subject", "주어 (Subject)")}</Label>
+            <Select
+              {...claimForm.register("subject_entity_id", {
+                valueAsNumber: true,
+              })}
+            >
+              <option value={0}>
+                {t("editor.pickSubject", "엔티티 선택...")}
+              </option>
+              {entities.data?.map((e) => (
+                <option key={e.id} value={e.id}>
+                  [{e.type}] {e.name}
+                </option>
+              ))}
+            </Select>
+            {claimForm.formState.errors.subject_entity_id && (
+              <p className="text-xs text-danger">
+                {claimForm.formState.errors.subject_entity_id.message}
+              </p>
+            )}
+          </div>
+
+          <div className="space-y-1.5">
+            <Label>{t("editor.predicate", "술어 (Predicate)")}</Label>
+            <Select {...claimForm.register("predicate")}>
+              <option value="">{t("editor.pickPredicate", "술어 선택...")}</option>
+              {predicateOptions.map((p) => (
+                <option key={p} value={p}>
+                  {p}
+                </option>
+              ))}
+            </Select>
+          </div>
+
+          <div className="space-y-1.5">
+            <Label>{t("editor.objectKind", "목적어 유형")}</Label>
+            <Select {...claimForm.register("object_kind")}>
+              <option value="entity">
+                {t("editor.objectEntity", "다른 엔티티")}
+              </option>
+              <option value="value">
+                {t("editor.objectValue", "리터럴 값")}
+              </option>
+            </Select>
+          </div>
+
+          {objectKind === "entity" ? (
+            <div className="space-y-1.5">
+              <Label>{t("editor.objectEntity", "목적 엔티티")}</Label>
+              <Select
+                {...claimForm.register("object_entity_id", {
+                  valueAsNumber: true,
+                  setValueAs: (v) =>
+                    v === "" || v === null || v === undefined
+                      ? null
+                      : Number(v),
+                })}
               >
-                {bulkCreate.isPending ? (
-                  <Loader2 className="h-4 w-4 animate-spin" />
-                ) : (
-                  <FileJson className="h-4 w-4" />
-                )}
-                {t("editor.bulkSubmit", "일괄 추가")}
-              </Button>
-            </CardContent>
-          </Card>
-        </TabsContent>
-      </Tabs>
-    </div>
+                <option value="">
+                  {t("editor.pickObject", "엔티티 선택...")}
+                </option>
+                {entities.data?.map((e) => (
+                  <option key={e.id} value={e.id}>
+                    [{e.type}] {e.name}
+                  </option>
+                ))}
+              </Select>
+            </div>
+          ) : (
+            <div className="space-y-1.5">
+              <Label>{t("editor.objectValue", "값")}</Label>
+              <Input
+                placeholder="2024-01-15 또는 임의 문자열"
+                {...claimForm.register("object_value")}
+              />
+            </div>
+          )}
+
+          <div className="space-y-1.5">
+            <Label>{t("editor.confidence", "신뢰도")}</Label>
+            <Input
+              type="number"
+              step="0.05"
+              min={0}
+              max={1}
+              {...claimForm.register("confidence", { valueAsNumber: true })}
+            />
+          </div>
+        </form>
+      </Drawer>
+    </>
   );
 }
diff --git a/ontology_platform/web/frontend/src/pages/QualityInspectorPage.tsx b/ontology_platform/web/frontend/src/pages/QualityInspectorPage.tsx
index bf6e9d2..6f348dd 100644
--- a/ontology_platform/web/frontend/src/pages/QualityInspectorPage.tsx
+++ b/ontology_platform/web/frontend/src/pages/QualityInspectorPage.tsx
@@ -1,24 +1,34 @@
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
 import { useNavigate, useParams } from "react-router-dom";
 import {
-  AlertCircle,
   AlertTriangle,
-  ArrowLeft,
   ClipboardCheck,
-  Link,
+  Link as LinkIcon,
+  RefreshCw,
   ShieldAlert,
 } from "lucide-react";
 import {
   Card,
   CardContent,
-  CardDescription,
   CardHeader,
   CardTitle,
 } from "@/components/ui/card";
 import { Badge, BadgeProps } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Progress } from "@/components/ui/progress";
-import { Skeleton } from "@/components/ui/skeleton";
+import { DataTable, type ColumnDef } from "@/components/ui/data-table";
+import { Drawer } from "@/components/ui/drawer";
+import { EmptyState } from "@/components/ui/empty-state";
+import { ErrorState } from "@/components/ui/error-state";
+import { Tooltip } from "@/components/ui/tooltip";
+import {
+  FilterPanel,
+  FilterSearch,
+  FilterSelect,
+  FilterChips,
+  type ActiveChip,
+} from "@/components/ui/filter-panel";
+import { PageHeader } from "@/components/layout/PageHeader";
 import { useClaims } from "@/hooks/useClaims";
 import { useEntities } from "@/hooks/useEntities";
 import { useProject } from "@/hooks/useProjects";
@@ -28,6 +38,10 @@ import { Entity } from "@/lib/api/entities";
 import { OntologyRegistry } from "@/lib/api/platform";
 import { formatPercent, humanizeValue } from "@/lib/display";
 
+/* ============================================================
+ * Issue model
+ * ========================================================== */
+
 interface QualityIssue {
   id: string;
   type: string;
@@ -67,32 +81,26 @@ function severityVariant(severity: QualityIssue["severity"]): BadgeProps["varian
 function normalizedName(value: unknown): string {
   return humanizeValue(value).trim().toLowerCase().replace(/\s+/g, " ");
 }
-
 function claimObject(claim: Claim): string {
   return humanizeValue(claim.object ?? claim.object_value);
 }
-
 function claimValueType(claim: Claim): string | undefined {
   const valueType = (claim as Claim & { value_type?: unknown }).value_type;
   return typeof valueType === "string" && valueType.trim()
     ? valueType.trim()
     : undefined;
 }
-
 function relationKey(claim: Claim): string {
   return `${claim.subject ?? ""}|${claim.predicate}|${claimObject(claim)}`.toLowerCase();
 }
-
 function allowedIncludes(values: string[], value: string | undefined | null) {
   if (!value) return false;
   const normalized = value.toLowerCase();
   return values.some((item) => item.toLowerCase() === normalized);
 }
-
 function listLabel(values: string[]) {
   return values.length ? values.join(", ") : "-";
 }
-
 function ruleNumber(
   record: Record<string, unknown> | undefined,
   keys: string[],
@@ -104,7 +112,6 @@ function ruleNumber(
   }
   return undefined;
 }
-
 function minConfidenceFor(rule: RelationRule | undefined): number {
   return (
     ruleNumber(rule?.confidence_rules, [
@@ -114,7 +121,6 @@ function minConfidenceFor(rule: RelationRule | undefined): number {
     ]) ?? 0.7
   );
 }
-
 function daysSince(value: string | null | undefined): number | undefined {
   if (!value) return undefined;
   const time = new Date(value).getTime();
@@ -122,6 +128,10 @@ function daysSince(value: string | null | undefined): number | undefined {
   return (Date.now() - time) / 86_400_000;
 }
 
+/* ============================================================
+ * Issue computation — same logic as before, factored unchanged
+ * ========================================================== */
+
 function buildIssues(
   claims: Claim[],
   entities: Entity[],
@@ -170,7 +180,6 @@ function buildIssues(
         target,
       });
     }
-
     if (!sourceUrl || !evidence) {
       issues.push({
         id: `source-${claim.id}`,
@@ -190,7 +199,6 @@ function buildIssues(
         target,
       });
     }
-
     if (evidence && claim.subject && object) {
       const evidenceLower = evidence.toLowerCase();
       const subjectLower = normalizedName(claim.subject);
@@ -205,12 +213,12 @@ function buildIssues(
           type: "weak_evidence_alignment",
           severity: "low",
           title: "Evidence does not mention the relation terms",
-          detail: "The snippet may support the page generally, but not this exact relation.",
+          detail:
+            "The snippet may support the page generally, but not this exact relation.",
           target,
         });
       }
     }
-
     const minConfidence = minConfidenceFor(rule);
     if (typeof claim.confidence !== "number") {
       issues.push({
@@ -225,13 +233,15 @@ function buildIssues(
       issues.push({
         id: `confidence-${claim.id}`,
         type: "low_confidence",
-        severity: claim.confidence < Math.max(0.45, minConfidence - 0.25) ? "high" : "medium",
+        severity:
+          claim.confidence < Math.max(0.45, minConfidence - 0.25)
+            ? "high"
+            : "medium",
         title: "Confidence is below rule threshold",
         detail: `${formatPercent(claim.confidence)} is below ${formatPercent(minConfidence)}.`,
         target,
       });
     }
-
     if (rule?.allowed_subject_types.length) {
       if (!subjectType) {
         issues.push({
@@ -253,7 +263,6 @@ function buildIssues(
         });
       }
     }
-
     if (rule?.allowed_object_types.length) {
       if (!objectType) {
         issues.push({
@@ -275,7 +284,6 @@ function buildIssues(
         });
       }
     }
-
     if (rule?.allowed_page_types.length) {
       if (!claim.page_type) {
         issues.push({
@@ -297,7 +305,6 @@ function buildIssues(
         });
       }
     }
-
     if (rule?.allowed_source_zones.length) {
       if (!claim.source_zone) {
         issues.push({
@@ -308,7 +315,9 @@ function buildIssues(
           detail: `Allowed source zones: ${listLabel(rule.allowed_source_zones)}.`,
           target,
         });
-      } else if (!allowedIncludes(rule.allowed_source_zones, claim.source_zone)) {
+      } else if (
+        !allowedIncludes(rule.allowed_source_zones, claim.source_zone)
+      ) {
         issues.push({
           id: `source-zone-${claim.id}`,
           type: "source_zone_mismatch",
@@ -319,7 +328,6 @@ function buildIssues(
         });
       }
     }
-
     if (
       claim.validation_status &&
       !okValidationStatuses.has(claim.validation_status.toLowerCase())
@@ -333,7 +341,6 @@ function buildIssues(
         target,
       });
     }
-
     if (
       claim.graph_merge_status &&
       !okGraphStatuses.has(claim.graph_merge_status.toLowerCase())
@@ -347,18 +354,17 @@ function buildIssues(
         target,
       });
     }
-
     if (claim.review_required || claim.conflict_status) {
       issues.push({
         id: `review-${claim.id}`,
         type: "review_required",
         severity: claim.conflict_status ? "high" : "medium",
         title: "Human review is required",
-        detail: claim.review_reason || claim.conflict_status || "review required",
+        detail:
+          claim.review_reason || claim.conflict_status || "review required",
         target,
       });
     }
-
     const staleDays = daysSince(claim.last_seen_at);
     if (staleDays === undefined) {
       issues.push({
@@ -379,7 +385,6 @@ function buildIssues(
         target,
       });
     }
-
     const subjectLabel = normalizedName(claim.subject);
     const objectLabel = normalizedName(object);
     if (genericLabels.has(subjectLabel) || subjectLabel.length <= 1) {
@@ -388,7 +393,8 @@ function buildIssues(
         type: "generic_subject",
         severity: "medium",
         title: "Subject label is too generic",
-        detail: "Generic entity labels should be normalized before graph commit.",
+        detail:
+          "Generic entity labels should be normalized before graph commit.",
         target,
       });
     }
@@ -398,11 +404,11 @@ function buildIssues(
         type: "generic_object",
         severity: "low",
         title: "Object label is too generic",
-        detail: "The object value may need a more specific entity or literal label.",
+        detail:
+          "The object value may need a more specific entity or literal label.",
         target,
       });
     }
-
     const key = relationKey(claim);
     const existing = seenRelations.get(key);
     if (existing) {
@@ -420,7 +426,6 @@ function buildIssues(
     if (claim.subject) connectedNames.add(normalizedName(claim.subject));
     if (object) connectedNames.add(normalizedName(object));
   }
-
   for (const group of entityNameGroups.values()) {
     if (group.length > 1) {
       issues.push({
@@ -433,7 +438,6 @@ function buildIssues(
       });
     }
   }
-
   for (const entity of entities) {
     const entityName = normalizedName(entity.name);
     if (!connectedNames.has(entityName)) {
@@ -442,11 +446,14 @@ function buildIssues(
         type: "isolated_entity",
         severity: "low",
         title: "Entity is isolated",
-        detail: "No relation currently connects to this entity in the loaded claim set.",
+        detail:
+          "No relation currently connects to this entity in the loaded claim set.",
         target: `[${entity.type}] ${entity.name}`,
       });
     }
-    if (["entity", "unknown", "unknown_entity"].includes(entity.type.toLowerCase())) {
+    if (
+      ["entity", "unknown", "unknown_entity"].includes(entity.type.toLowerCase())
+    ) {
       issues.push({
         id: `generic-entity-type-${entity.id}`,
         type: "generic_entity_type",
@@ -457,7 +464,6 @@ function buildIssues(
       });
     }
   }
-
   return issues;
 }
 
@@ -471,6 +477,10 @@ function countByType(issues: QualityIssue[]) {
     .sort((a, b) => b.count - a.count);
 }
 
+/* ============================================================
+ * Page
+ * ========================================================== */
+
 export default function QualityInspectorPage() {
   const navigate = useNavigate();
   const { projectId } = useParams<{ projectId: string }>();
@@ -484,6 +494,11 @@ export default function QualityInspectorPage() {
   const registry = useOntologyRegistry(projectName);
   const pipeline = usePipeline(projectName);
 
+  const [severityFilter, setSeverityFilter] = useState("");
+  const [typeFilter, setTypeFilter] = useState("");
+  const [search, setSearch] = useState("");
+  const [selectedIssue, setSelectedIssue] = useState<QualityIssue | null>(null);
+
   const issues = useMemo(
     () =>
       buildIssues(
@@ -493,14 +508,28 @@ export default function QualityInspectorPage() {
       ),
     [claims.data, entities.data, registry.data?.relation_types],
   );
-  const high = issues.filter((issue) => issue.severity === "high").length;
-  const medium = issues.filter((issue) => issue.severity === "medium").length;
-  const low = issues.filter((issue) => issue.severity === "low").length;
+
+  const filteredIssues = useMemo(() => {
+    const q = search.trim().toLowerCase();
+    return issues.filter((issue) => {
+      if (severityFilter && issue.severity !== severityFilter) return false;
+      if (typeFilter && issue.type !== typeFilter) return false;
+      if (!q) return true;
+      return [issue.title, issue.detail, issue.target, issue.type]
+        .map((v) => v.toLowerCase())
+        .some((v) => v.includes(q));
+    });
+  }, [issues, severityFilter, typeFilter, search]);
+
+  const high = issues.filter((i) => i.severity === "high").length;
+  const medium = issues.filter((i) => i.severity === "medium").length;
+  const low = issues.filter((i) => i.severity === "low").length;
   const score = Math.max(
     0,
     Math.round(100 - high * 10 - medium * 5 - low * 1.5),
   );
   const issueCounts = countByType(issues);
+
   const relationRuleNames = new Set(
     (registry.data?.relation_types ?? []).map((row) => row.name),
   );
@@ -517,274 +546,515 @@ export default function QualityInspectorPage() {
   const reviewRate = claims.data?.length
     ? reviewedCount / claims.data.length
     : 0;
-  const schemaIssueCount = issues.filter((issue) =>
-    [
-      "unknown_predicate",
-      "subject_type_mismatch",
-      "object_type_mismatch",
-      "page_type_mismatch",
-      "source_zone_mismatch",
-      "schema_violation",
-    ].includes(issue.type),
-  ).length;
-  const evidenceIssueCount = issues.filter((issue) =>
-    ["missing_source", "thin_evidence", "weak_evidence_alignment"].includes(
-      issue.type,
-    ),
-  ).length;
-  const visibleIssues = issues.slice(0, 250);
+
+  const isLoading =
+    claims.isLoading || entities.isLoading || registry.isLoading;
+  const errorObj =
+    (claims.error as Error | undefined) ??
+    (entities.error as Error | undefined) ??
+    (registry.error as Error | undefined);
+
+  /* ----- Filter chips ----- */
+  const chips: ActiveChip[] = [];
+  if (search)
+    chips.push({
+      id: "search",
+      label: "Search",
+      value: `"${search}"`,
+      onClear: () => setSearch(""),
+    });
+  if (severityFilter)
+    chips.push({
+      id: "sev",
+      label: "Severity",
+      value: severityFilter,
+      onClear: () => setSeverityFilter(""),
+    });
+  if (typeFilter)
+    chips.push({
+      id: "type",
+      label: "Type",
+      value: typeFilter,
+      onClear: () => setTypeFilter(""),
+    });
+  const clearAll = () => {
+    setSearch("");
+    setSeverityFilter("");
+    setTypeFilter("");
+  };
+
+  /* ----- Table columns ----- */
+  const columns: ColumnDef<QualityIssue, any>[] = [
+    {
+      id: "severity",
+      header: "Severity",
+      accessorFn: (row) =>
+        row.severity === "high" ? 0 : row.severity === "medium" ? 1 : 2,
+      cell: ({ row }) => (
+        <Badge variant={severityVariant(row.original.severity)}>
+          {row.original.severity}
+        </Badge>
+      ),
+      size: 110,
+      enablePinning: true,
+    },
+    {
+      id: "type",
+      header: "Type",
+      accessorFn: (row) => row.type,
+      cell: ({ row }) => (
+        <span className="pill-muted font-mono">{row.original.type}</span>
+      ),
+      size: 200,
+    },
+    {
+      id: "title",
+      header: "Title",
+      accessorFn: (row) => row.title,
+      cell: ({ row }) => (
+        <span className="font-medium text-foreground">{row.original.title}</span>
+      ),
+      size: 280,
+    },
+    {
+      id: "target",
+      header: "Target",
+      accessorFn: (row) => row.target,
+      cell: ({ row }) => (
+        <span className="line-clamp-2 break-words text-xs text-muted-foreground">
+          {row.original.target}
+        </span>
+      ),
+      size: 320,
+      enableSorting: false,
+    },
+  ];
 
   return (
-    <div className="mx-auto max-w-7xl px-6 py-8">
-      <div className="mb-6 flex items-center gap-3">
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => navigate(`/review/${projectName}`)}
-          aria-label="Back"
-        >
-          <ArrowLeft className="h-4 w-4" />
-        </Button>
-        <div className="flex-1">
-          <h1 className="flex items-center gap-2 text-2xl font-bold tracking-tight">
-            <ClipboardCheck className="h-6 w-6 text-primary" />
-            Quality Inspector
-          </h1>
-          <p className="text-sm text-muted-foreground">
-            {project?.name ?? projectName} schema, evidence, duplicate, and graph readiness checks.
-          </p>
+    <>
+      <PageHeader
+        icon={ClipboardCheck}
+        breadcrumbs={[
+          { label: "Dashboard", to: "/" },
+          { label: projectName, to: `/sources/${projectName}` },
+          { label: "Quality Inspector" },
+        ]}
+        title="Quality Inspector"
+        description={`${project?.name ?? projectName} · schema, evidence, duplicate, and graph readiness checks`}
+        actions={
+          <Tooltip content="Refresh all metrics" shortcut="R">
+            <Button
+              variant="outline"
+              onClick={() => {
+                claims.refetch();
+                entities.refetch();
+                registry.refetch();
+                pipeline.refetch();
+              }}
+            >
+              <RefreshCw className="h-4 w-4" />
+              Refresh
+            </Button>
+          </Tooltip>
+        }
+      />
+
+      <div className="mx-auto max-w-7xl px-6 py-6">
+        {errorObj && (
+          <ErrorState
+            className="mb-4"
+            inline
+            severity="error"
+            title="Failed to load quality data"
+            description={errorObj}
+            onRetry={() => {
+              claims.refetch();
+              entities.refetch();
+              registry.refetch();
+            }}
+          />
+        )}
+
+        {/* Top metrics */}
+        <div className="mb-4 grid gap-3 sm:grid-cols-2 lg:grid-cols-5">
+          <Card className="border-border">
+            <CardContent className="py-3">
+              <div className="text-2xs uppercase tracking-wider text-muted-foreground">
+                Quality Score
+              </div>
+              <div className="mt-1 flex items-baseline gap-1.5">
+                <span className="text-3xl font-semibold tabular-nums text-foreground">
+                  {score}
+                </span>
+                <span className="text-sm text-muted-foreground">/ 100</span>
+              </div>
+              <Progress value={score} className="mt-2" />
+            </CardContent>
+          </Card>
+          <Metric label="High" value={high} tone="danger" />
+          <Metric label="Medium" value={medium} tone="warning" />
+          <Metric label="Low" value={low} tone="muted" />
+          <Metric
+            label="Review Rate"
+            value={formatPercent(reviewRate)}
+            tone={reviewRate >= 0.8 ? "success" : "warning"}
+          />
         </div>
-        <Button
-          variant="outline"
-          onClick={() => {
-            claims.refetch();
-            entities.refetch();
-            registry.refetch();
-            pipeline.refetch();
-          }}
-        >
-          Refresh
-        </Button>
-      </div>
 
-      {(claims.isError || entities.isError || registry.isError) && (
-        <Card className="mb-6 border-destructive">
-          <CardContent className="flex items-center gap-2 py-4 text-sm text-destructive">
-            <AlertCircle className="h-4 w-4" />
-            {(claims.error as Error | undefined)?.message ??
-              (entities.error as Error | undefined)?.message ??
-              (registry.error as Error | undefined)?.message}
-          </CardContent>
-        </Card>
-      )}
+        <div className="grid gap-4 xl:grid-cols-[minmax(0,1fr)_340px]">
+          <div className="min-w-0 space-y-3">
+            <FilterPanel
+              chips={chips.length > 0 ? <FilterChips chips={chips} /> : undefined}
+              onClearAll={chips.length > 0 ? clearAll : undefined}
+            >
+              <FilterSearch
+                value={search}
+                onChange={setSearch}
+                placeholder="Search issues by title, detail, target…"
+              />
+              <FilterSelect
+                label="Severity"
+                value={severityFilter}
+                onChange={setSeverityFilter}
+                placeholder="All severities"
+                options={[
+                  { value: "high", label: "High", hint: high, swatch: "hsl(var(--danger))" },
+                  { value: "medium", label: "Medium", hint: medium, swatch: "hsl(var(--warning))" },
+                  { value: "low", label: "Low", hint: low, swatch: "hsl(var(--muted-foreground))" },
+                ]}
+              />
+              <FilterSelect
+                label="Type"
+                value={typeFilter}
+                onChange={setTypeFilter}
+                placeholder="All types"
+                options={issueCounts.map(({ type, count }) => ({
+                  value: type,
+                  label: type,
+                  hint: count,
+                }))}
+              />
+            </FilterPanel>
 
-      <div className="mb-6 grid gap-4 md:grid-cols-5">
-        <Card>
-          <CardContent className="py-4">
-            <div className="text-xs text-muted-foreground">Quality score</div>
-            <div className="mt-1 text-3xl font-semibold">{score}</div>
-            <Progress value={score} className="mt-3" />
-          </CardContent>
-        </Card>
-        <Metric label="High" value={high} tone="high" />
-        <Metric label="Medium" value={medium} tone="medium" />
-        <Metric label="Low" value={low} tone="low" />
-        <Metric label="Review rate" value={formatPercent(reviewRate)} />
-      </div>
+            <DataTable<QualityIssue>
+              tableId="quality-issues"
+              columns={columns}
+              data={filteredIssues}
+              getRowId={(row) => row.id}
+              loading={isLoading}
+              loadingRows={8}
+              height={560}
+              onRowClick={(row) => setSelectedIssue(row)}
+              rowToneAccessor={(row) =>
+                row.severity === "high"
+                  ? "danger"
+                  : row.severity === "medium"
+                    ? "warning"
+                    : undefined
+              }
+              empty={
+                <EmptyState
+                  icon={ClipboardCheck}
+                  title="No quality warnings"
+                  description={
+                    issues.length > 0
+                      ? "All issues filtered out. Try clearing filters."
+                      : "The loaded scope is clean. Great work."
+                  }
+                  primaryAction={
+                    chips.length > 0 ? (
+                      <Button variant="outline" onClick={clearAll}>
+                        Clear filters
+                      </Button>
+                    ) : undefined
+                  }
+                />
+              }
+            />
+          </div>
 
-      <div className="grid gap-6 lg:grid-cols-[1fr_360px]">
-        <Card>
-          <CardHeader>
-            <div className="flex flex-wrap items-center justify-between gap-3">
-              <CardTitle>Validation Issues</CardTitle>
-              {issues.length > visibleIssues.length && (
-                <Badge variant="outline">
-                  Showing {visibleIssues.length} of {issues.length}
-                </Badge>
-              )}
-            </div>
-            <CardDescription>
-              Rule-based warnings generated from claim evidence and ontology registry constraints.
-            </CardDescription>
-          </CardHeader>
-          <CardContent>
-            {(claims.isLoading || entities.isLoading || registry.isLoading) && (
-              <div className="space-y-3">
-                {Array.from({ length: 5 }).map((_, index) => (
-                  <Skeleton key={index} className="h-20" />
-                ))}
-              </div>
-            )}
-            {!claims.isLoading &&
-              !entities.isLoading &&
-              !registry.isLoading &&
-              issues.length === 0 && (
-                <div className="flex flex-col items-center gap-2 py-12 text-center text-sm text-muted-foreground">
-                  <ClipboardCheck className="h-10 w-10 opacity-50" />
-                  No quality warnings were found in the loaded scope.
-                </div>
-            )}
-            <div className="space-y-3">
-              {visibleIssues.map((issue) => (
-                <article key={issue.id} className="rounded-md border p-4">
-                  <div className="flex flex-wrap items-center gap-2">
-                    <Badge variant={severityVariant(issue.severity)}>
-                      {issue.severity}
-                    </Badge>
-                    <Badge variant="outline">{issue.type}</Badge>
-                    <span className="font-medium">{issue.title}</span>
-                  </div>
-                  <p className="mt-2 text-sm text-muted-foreground">
-                    {issue.detail}
-                  </p>
-                  <div className="mt-2 rounded-md bg-secondary/30 px-3 py-2 text-sm">
-                    {issue.target}
-                  </div>
-                </article>
-              ))}
-            </div>
-          </CardContent>
-        </Card>
-
-        <div className="space-y-6">
-          <Card>
-            <CardHeader>
-              <CardTitle className="flex items-center gap-2">
-                <ShieldAlert className="h-5 w-5" />
-                Schema Coverage
-              </CardTitle>
-              <CardDescription>
-                Predicate and type coverage against the ontology registry.
-              </CardDescription>
-            </CardHeader>
-            <CardContent className="space-y-3">
-              <ReadinessRow label="Relation rules" value={relationRuleNames.size} />
-              <ReadinessRow label="Schema warnings" value={schemaIssueCount} />
-              <ReadinessRow label="Evidence warnings" value={evidenceIssueCount} />
-              <div className="flex items-center justify-between text-sm">
-                <span>Unknown predicates</span>
-                <Badge variant={unknownPredicates.length ? "warning" : "success"}>
-                  {unknownPredicates.length}
-                </Badge>
-              </div>
-              <div className="flex flex-wrap gap-2">
-                {unknownPredicates.map((predicate) => (
-                  <Badge key={predicate} variant="outline">
-                    {predicate}
-                  </Badge>
-                ))}
-                {unknownPredicates.length === 0 && (
-                  <span className="text-sm text-muted-foreground">
-                    All loaded predicates are registered.
+          {/* Right rail */}
+          <div className="space-y-4">
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-sm">
+                  <ShieldAlert className="h-4 w-4" />
+                  Schema Coverage
+                </CardTitle>
+              </CardHeader>
+              <CardContent className="space-y-2">
+                <ReadinessRow
+                  label="Relation rules"
+                  value={relationRuleNames.size}
+                />
+                <ReadinessRow
+                  label="Schema warnings"
+                  value={
+                    issues.filter((i) =>
+                      [
+                        "unknown_predicate",
+                        "subject_type_mismatch",
+                        "object_type_mismatch",
+                        "page_type_mismatch",
+                        "source_zone_mismatch",
+                        "schema_violation",
+                      ].includes(i.type),
+                    ).length
+                  }
+                />
+                <ReadinessRow
+                  label="Evidence warnings"
+                  value={
+                    issues.filter((i) =>
+                      [
+                        "missing_source",
+                        "thin_evidence",
+                        "weak_evidence_alignment",
+                      ].includes(i.type),
+                    ).length
+                  }
+                />
+                <div className="flex items-center justify-between text-sm">
+                  <span className="text-muted-foreground">
+                    Unknown predicates
                   </span>
-                )}
-              </div>
-            </CardContent>
-          </Card>
-
-          <Card>
-            <CardHeader>
-              <CardTitle className="flex items-center gap-2">
-                <Link className="h-5 w-5" />
-                Graph Readiness
-              </CardTitle>
-              <CardDescription>Build output ready for graph and exports.</CardDescription>
-            </CardHeader>
-            <CardContent className="space-y-3">
-              <ReadinessRow
-                label="Collected pages"
-                value={
-                  pipeline.data?.stages.find((stage) => stage.key === "crawled")
-                    ?.count ?? 0
-                }
-              />
-              <ReadinessRow
-                label="Approved claims"
-                value={
-                  pipeline.data?.stages.find((stage) => stage.key === "validated")
-                    ?.count ?? 0
-                }
-              />
-              <ReadinessRow
-                label="Graph triples"
-                value={
-                  pipeline.data?.stages.find((stage) => stage.key === "graph")
-                    ?.count ?? 0
-                }
-              />
-            </CardContent>
-          </Card>
-
-          <Card>
-            <CardHeader>
-              <CardTitle className="flex items-center gap-2">
-                <AlertTriangle className="h-5 w-5" />
-                Issue Mix
-              </CardTitle>
-            </CardHeader>
-            <CardContent>
-              <ul className="space-y-2 text-sm">
-                {issueCounts.slice(0, 8).map((item) => (
-                  <li
-                    key={item.type}
-                    className="flex items-center justify-between rounded-md border px-3 py-2"
+                  <Badge
+                    variant={unknownPredicates.length ? "warning" : "success"}
                   >
-                    <span>{item.type}</span>
-                    <span className="font-medium">{item.count}</span>
-                  </li>
-                ))}
-                {issueCounts.length === 0 && (
-                  <li className="py-4 text-center text-muted-foreground">
-                    No issues in the loaded scope.
-                  </li>
-                )}
-              </ul>
-            </CardContent>
-          </Card>
-
-          <Card>
-            <CardHeader>
-              <CardTitle>Recommended Actions</CardTitle>
-            </CardHeader>
-            <CardContent>
-              <ul className="space-y-2 text-sm text-muted-foreground">
-                {high > 0 && (
-                  <li>Resolve missing evidence, type violations, and conflicts before export.</li>
-                )}
-                {medium > 0 && (
-                  <li>Review stale claims, thin evidence, duplicate relations, and missing rule fields.</li>
-                )}
+                    {unknownPredicates.length}
+                  </Badge>
+                </div>
                 {unknownPredicates.length > 0 && (
-                  <li>Add missing predicate rules in Schema Designer.</li>
+                  <div className="flex flex-wrap gap-1.5 pt-1">
+                    {unknownPredicates.slice(0, 12).map((predicate) => (
+                      <Badge
+                        key={predicate}
+                        variant="outline"
+                        className="font-mono"
+                      >
+                        {predicate}
+                      </Badge>
+                    ))}
+                  </div>
                 )}
-                {score >= 90 && (
-                  <li>The ontology is ready for graph inspection and Export/API handoff.</li>
-                )}
-              </ul>
-            </CardContent>
-          </Card>
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-sm">
+                  <LinkIcon className="h-4 w-4" />
+                  Graph Readiness
+                </CardTitle>
+              </CardHeader>
+              <CardContent className="space-y-2">
+                <ReadinessRow
+                  label="Collected pages"
+                  value={
+                    pipeline.data?.stages.find((s) => s.key === "crawled")
+                      ?.count ?? 0
+                  }
+                />
+                <ReadinessRow
+                  label="Approved claims"
+                  value={
+                    pipeline.data?.stages.find((s) => s.key === "validated")
+                      ?.count ?? 0
+                  }
+                />
+                <ReadinessRow
+                  label="Graph triples"
+                  value={
+                    pipeline.data?.stages.find((s) => s.key === "graph")
+                      ?.count ?? 0
+                  }
+                />
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="flex items-center gap-2 text-sm">
+                  <AlertTriangle className="h-4 w-4" />
+                  Issue Mix
+                </CardTitle>
+              </CardHeader>
+              <CardContent>
+                <ul className="space-y-1.5 text-sm">
+                  {issueCounts.slice(0, 8).map((item) => (
+                    <li
+                      key={item.type}
+                      className="flex items-center justify-between rounded-md border border-border bg-background-subtle px-3 py-1.5"
+                    >
+                      <button
+                        type="button"
+                        onClick={() => setTypeFilter(item.type)}
+                        className="truncate text-left font-mono text-xs hover:underline"
+                        title="Filter by this type"
+                      >
+                        {item.type}
+                      </button>
+                      <span className="font-medium tabular-nums">
+                        {item.count}
+                      </span>
+                    </li>
+                  ))}
+                  {issueCounts.length === 0 && (
+                    <li className="py-4 text-center text-xs text-muted-foreground">
+                      No issues in scope.
+                    </li>
+                  )}
+                </ul>
+              </CardContent>
+            </Card>
+
+            <Card>
+              <CardHeader>
+                <CardTitle className="text-sm">Recommendations</CardTitle>
+              </CardHeader>
+              <CardContent>
+                <ul className="space-y-2 text-sm text-muted-foreground">
+                  {high > 0 && (
+                    <li>
+                      Resolve missing evidence, type violations, and conflicts before export.
+                    </li>
+                  )}
+                  {medium > 0 && (
+                    <li>
+                      Review stale claims, thin evidence, duplicates, and missing rule fields.
+                    </li>
+                  )}
+                  {unknownPredicates.length > 0 && (
+                    <li>
+                      Add missing predicate rules in{" "}
+                      <button
+                        type="button"
+                        onClick={() => navigate(`/schema/${projectName}`)}
+                        className="text-brand-600 hover:underline dark:text-brand-300"
+                      >
+                        Schema Designer
+                      </button>
+                      .
+                    </li>
+                  )}
+                  {score >= 90 && (
+                    <li className="text-success">
+                      The ontology is ready for graph inspection and Export/API handoff.
+                    </li>
+                  )}
+                  {issues.length === 0 && !isLoading && (
+                    <li className="text-success">
+                      No warnings — quality looks great.
+                    </li>
+                  )}
+                </ul>
+              </CardContent>
+            </Card>
+          </div>
         </div>
       </div>
-    </div>
+
+      {/* Issue detail Drawer */}
+      <Drawer
+        open={!!selectedIssue}
+        onOpenChange={(open) => {
+          if (!open) setSelectedIssue(null);
+        }}
+        size="md"
+        title={selectedIssue?.title ?? ""}
+        description="Issue detail and remediation"
+        headerExtra={
+          selectedIssue ? (
+            <Badge variant={severityVariant(selectedIssue.severity)}>
+              {selectedIssue.severity}
+            </Badge>
+          ) : null
+        }
+        footer={
+          selectedIssue ? (
+            <Button
+              variant="outline"
+              onClick={() => navigate(`/review/${projectName}`)}
+            >
+              Open in Claim Review
+            </Button>
+          ) : null
+        }
+      >
+        {selectedIssue && (
+          <div className="space-y-4">
+            <div className="rounded-md border border-border bg-background-subtle p-3">
+              <div className="text-2xs uppercase tracking-wider text-muted-foreground">
+                Type
+              </div>
+              <div className="mt-1 font-mono text-sm">{selectedIssue.type}</div>
+            </div>
+
+            <section>
+              <h3 className="mb-1.5 text-2xs font-semibold uppercase tracking-wider text-muted-foreground">
+                Detail
+              </h3>
+              <p className="text-sm leading-relaxed text-foreground">
+                {selectedIssue.detail}
+              </p>
+            </section>
+
+            <section>
+              <h3 className="mb-1.5 text-2xs font-semibold uppercase tracking-wider text-muted-foreground">
+                Target
+              </h3>
+              <blockquote className="rounded-md border-l-4 border-brand-500 bg-background-subtle px-3 py-2 text-sm leading-relaxed text-foreground">
+                {selectedIssue.target}
+              </blockquote>
+            </section>
+
+            <section>
+              <h3 className="mb-1.5 text-2xs font-semibold uppercase tracking-wider text-muted-foreground">
+                Suggested action
+              </h3>
+              <p className="text-sm text-muted-foreground">
+                {selectedIssue.severity === "high"
+                  ? "Fix before exporting — this can corrupt downstream graph or API output."
+                  : selectedIssue.severity === "medium"
+                    ? "Review during the next QA pass to maintain ontology hygiene."
+                    : "Optional cleanup — low impact on graph integrity."}
+              </p>
+            </section>
+          </div>
+        )}
+      </Drawer>
+    </>
   );
 }
 
+/* ============================================================
+ * Sub-components
+ * ========================================================== */
+
+const METRIC_TONE: Record<string, string> = {
+  muted: "border-border",
+  warning: "border-warning-border bg-warning-subtle/30",
+  success: "border-success-border bg-success-subtle/30",
+  danger: "border-danger-border bg-danger-subtle/30",
+};
+
 function Metric({
   label,
   value,
-  tone,
+  tone = "muted",
 }: {
   label: string;
   value: number | string;
-  tone?: QualityIssue["severity"];
+  tone?: keyof typeof METRIC_TONE;
 }) {
   return (
-    <Card>
-      <CardContent className="py-4">
-        <div className="text-xs text-muted-foreground">{label}</div>
-        <div className="mt-1 flex items-center justify-between gap-2">
-          <span className="text-2xl font-semibold">{value}</span>
-          {tone && <Badge variant={severityVariant(tone)}>{tone}</Badge>}
+    <Card className={`border ${METRIC_TONE[tone]}`}>
+      <CardContent className="py-3">
+        <div className="text-2xs uppercase tracking-wider text-muted-foreground">
+          {label}
+        </div>
+        <div className="mt-1 text-2xl font-semibold tabular-nums text-foreground">
+          {value}
         </div>
       </CardContent>
     </Card>
@@ -793,9 +1063,9 @@ function Metric({
 
 function ReadinessRow({ label, value }: { label: string; value: number }) {
   return (
-    <div className="flex items-center justify-between rounded-md border px-3 py-2 text-sm">
+    <div className="flex items-center justify-between text-sm">
       <span className="text-muted-foreground">{label}</span>
-      <span className="font-medium">{value.toLocaleString()}</span>
+      <span className="font-medium tabular-nums">{value.toLocaleString()}</span>
     </div>
   );
 }
diff --git a/ontology_platform/web/frontend/src/pages/ReviewPage.tsx b/ontology_platform/web/frontend/src/pages/ReviewPage.tsx
index 6c2a54c..b2a03b8 100644
--- a/ontology_platform/web/frontend/src/pages/ReviewPage.tsx
+++ b/ontology_platform/web/frontend/src/pages/ReviewPage.tsx
@@ -1,30 +1,31 @@
+import * as React from "react";
 import { useMemo, useState } from "react";
 import { useNavigate, useParams } from "react-router-dom";
 import { toast } from "sonner";
 import {
-  AlertCircle,
-  ArrowLeft,
   ArrowRight,
   Check,
-  Eye,
-  Filter,
+  ExternalLink,
   ListChecks,
-  Search,
+  ShieldCheck,
   X,
 } from "lucide-react";
-import { cn } from "@/lib/utils";
-import {
-  Card,
-  CardContent,
-  CardDescription,
-  CardHeader,
-  CardTitle,
-} from "@/components/ui/card";
+import { Card, CardContent } from "@/components/ui/card";
 import { Badge, BadgeProps } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { Select } from "@/components/ui/select";
-import { Skeleton } from "@/components/ui/skeleton";
+import { DataTable, type ColumnDef } from "@/components/ui/data-table";
+import { Drawer } from "@/components/ui/drawer";
+import { EmptyState } from "@/components/ui/empty-state";
+import { ErrorState } from "@/components/ui/error-state";
+import { Tooltip } from "@/components/ui/tooltip";
+import {
+  FilterPanel,
+  FilterSearch,
+  FilterSelect,
+  FilterChips,
+  type ActiveChip,
+} from "@/components/ui/filter-panel";
+import { PageHeader } from "@/components/layout/PageHeader";
 import { useClaims, useUpdateClaimStatus } from "@/hooks/useClaims";
 import { useProject } from "@/hooks/useProjects";
 import {
@@ -50,15 +51,21 @@ function statusVariant(status: string | undefined): BadgeProps["variant"] {
 
 function confidenceBucket(claim: Claim): string {
   if (typeof claim.confidence !== "number") return "unknown";
-  if (claim.confidence >= 0.9) return "auto-approve candidate";
-  if (claim.confidence >= 0.7) return "normal review";
-  return "priority review";
+  if (claim.confidence >= 0.9) return "auto-approve";
+  if (claim.confidence >= 0.7) return "normal";
+  return "priority";
 }
 
-function claimObject(claim: Claim): string {
+function claimObjectText(claim: Claim): string {
   return humanizeValue(claim.object ?? claim.object_value);
 }
 
+const STATUS_LABELS: Record<string, string> = {
+  candidate: "Candidate",
+  approved: "Approved",
+  rejected: "Rejected",
+};
+
 export default function ReviewPage() {
   const navigate = useNavigate();
   const { projectId } = useParams<{ projectId: string }>();
@@ -66,24 +73,28 @@ export default function ReviewPage() {
   const { data: project } = useProject(projectName);
   const claims = useClaims(projectName, {
     includeCandidates: true,
-    limit: 300,
+    limit: 500,
   });
   const updateStatus = useUpdateClaimStatus(projectName);
-  const [statusFilter, setStatusFilter] = useState("all");
+
+  const [statusFilter, setStatusFilter] = useState<string>("");
   const [search, setSearch] = useState("");
   const [selectedId, setSelectedId] = useState<string | null>(null);
+  const [drawerOpen, setDrawerOpen] = useState(false);
+
+  /* --------------------- Derived data --------------------- */
 
   const filteredClaims = useMemo(() => {
     const query = search.trim().toLowerCase();
     return (claims.data ?? []).filter((claim) => {
-      if (statusFilter !== "all" && reviewLabel(claim.status) !== statusFilter) {
+      if (statusFilter && reviewLabel(claim.status) !== statusFilter) {
         return false;
       }
       if (!query) return true;
       return [
         claim.subject,
         claim.predicate,
-        claimObject(claim),
+        claimObjectText(claim),
         claim.evidence_text,
         claim.page_url,
         claim.source,
@@ -94,11 +105,9 @@ export default function ReviewPage() {
   }, [claims.data, search, statusFilter]);
 
   const selectedClaim = useMemo(() => {
-    return (
-      filteredClaims.find((claim) => claim.id === selectedId) ??
-      filteredClaims[0]
-    );
-  }, [filteredClaims, selectedId]);
+    if (!selectedId) return null;
+    return claims.data?.find((claim) => claim.id === selectedId) ?? null;
+  }, [claims.data, selectedId]);
 
   const counts = useMemo(() => {
     const all = claims.data ?? [];
@@ -113,6 +122,8 @@ export default function ReviewPage() {
     };
   }, [claims.data]);
 
+  /* --------------------- Actions --------------------- */
+
   const applyStatus = async (claim: Claim, status: string) => {
     try {
       await updateStatus.mutateAsync({
@@ -123,334 +134,491 @@ export default function ReviewPage() {
             ? "Rejected from Claim Review"
             : "Updated from Claim Review",
       });
-      toast.success(`Claim ${status}`);
+      toast.success(
+        status === "validated_claim"
+          ? `Approved · ${humanizeValue(claim.subject)}`
+          : `Rejected · ${humanizeValue(claim.subject)}`,
+      );
     } catch (error) {
       toast.error((error as Error).message);
     }
   };
 
-  return (
-    <div className="mx-auto max-w-7xl px-6 py-8">
-      <div className="mb-6 flex items-center gap-3">
-        <Button
-          variant="ghost"
-          size="icon"
-          onClick={() => navigate(`/schema/${projectName}`)}
-          aria-label="Back"
-        >
-          <ArrowLeft className="h-4 w-4" />
-        </Button>
-        <div className="flex-1">
-          <h1 className="flex items-center gap-2 text-2xl font-bold tracking-tight">
-            <ListChecks className="h-6 w-6 text-primary" />
-            Claim Review
-          </h1>
-          <p className="text-sm text-muted-foreground">
-            {project?.name ?? projectName} · 후보, 승인, 반려 상태 분리 검토
-          </p>
+  const openDetail = (claim: Claim) => {
+    setSelectedId(claim.id);
+    setDrawerOpen(true);
+  };
+
+  /* --------------------- Filter chips --------------------- */
+
+  const chips: ActiveChip[] = [];
+  if (search)
+    chips.push({
+      id: "search",
+      label: "Search",
+      value: `"${search}"`,
+      onClear: () => setSearch(""),
+    });
+  if (statusFilter)
+    chips.push({
+      id: "status",
+      label: "Status",
+      value: STATUS_LABELS[statusFilter] ?? statusFilter,
+      onClear: () => setStatusFilter(""),
+    });
+  const clearAll = () => {
+    setSearch("");
+    setStatusFilter("");
+  };
+
+  /* --------------------- Table columns --------------------- */
+
+  const columns: ColumnDef<Claim, any>[] = [
+    {
+      id: "status",
+      header: "Status",
+      accessorFn: (row) => reviewLabel(row.status),
+      cell: ({ row }) => (
+        <Badge variant={statusVariant(row.original.status)}>
+          {reviewLabel(row.original.status)}
+        </Badge>
+      ),
+      size: 110,
+      enablePinning: true,
+    },
+    {
+      id: "subject",
+      header: "Subject",
+      accessorFn: (row) => humanizeValue(row.subject),
+      cell: ({ row }) => (
+        <span className="line-clamp-2 break-words font-medium text-foreground">
+          {humanizeValue(row.original.subject)}
+        </span>
+      ),
+      size: 220,
+    },
+    {
+      id: "predicate",
+      header: "Predicate",
+      accessorFn: (row) => row.predicate,
+      cell: ({ row }) => (
+        <Badge variant="secondary" className="font-mono">
+          {row.original.predicate}
+        </Badge>
+      ),
+      size: 160,
+    },
+    {
+      id: "object",
+      header: "Object",
+      accessorFn: (row) => claimObjectText(row),
+      cell: ({ row }) => (
+        <span className="line-clamp-2 break-words text-foreground">
+          {claimObjectText(row.original)}
+        </span>
+      ),
+      size: 280,
+      enableSorting: false,
+    },
+    {
+      id: "confidence",
+      header: "Confidence",
+      accessorFn: (row) => row.confidence ?? 0,
+      cell: ({ row }) => <ConfidenceBar value={row.original.confidence} />,
+      size: 140,
+      meta: { align: "right" },
+    },
+    {
+      id: "bucket",
+      header: "Bucket",
+      accessorFn: (row) => confidenceBucket(row),
+      cell: ({ row }) => {
+        const b = confidenceBucket(row.original);
+        const tone =
+          b === "auto-approve"
+            ? "pill-success"
+            : b === "priority"
+              ? "pill-warning"
+              : "pill-info";
+        return <span className={tone}>{b}</span>;
+      },
+      size: 130,
+    },
+    {
+      id: "source",
+      header: "Source",
+      accessorFn: (row) => row.source ?? "",
+      cell: ({ row }) => (
+        <span className="text-xs text-muted-foreground">
+          {humanizeValue(row.original.source)}
+        </span>
+      ),
+      size: 120,
+    },
+    {
+      id: "evidence",
+      header: "Evidence",
+      accessorFn: (row) => (row.evidence_text ? 1 : 0),
+      cell: ({ row }) =>
+        row.original.evidence_text ? (
+          <span className="text-xs font-medium text-success">yes</span>
+        ) : (
+          <span className="text-xs font-medium text-warning">missing</span>
+        ),
+      size: 90,
+      meta: { align: "center" },
+    },
+    {
+      id: "actions",
+      header: "",
+      enableSorting: false,
+      enableHiding: false,
+      enableResizing: false,
+      cell: ({ row }) => (
+        <div className="flex items-center justify-end gap-1">
+          <Tooltip content="Approve" shortcut="A">
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={(e) => {
+                e.stopPropagation();
+                applyStatus(row.original, "validated_claim");
+              }}
+              disabled={updateStatus.isPending}
+              className="h-7 w-7"
+            >
+              <Check className="h-3.5 w-3.5 text-success" />
+            </Button>
+          </Tooltip>
+          <Tooltip content="Reject" shortcut="X">
+            <Button
+              variant="ghost"
+              size="icon"
+              onClick={(e) => {
+                e.stopPropagation();
+                applyStatus(row.original, "rejected");
+              }}
+              disabled={updateStatus.isPending}
+              className="h-7 w-7"
+            >
+              <X className="h-3.5 w-3.5 text-danger" />
+            </Button>
+          </Tooltip>
         </div>
-        <Button onClick={() => navigate(`/quality/${projectName}`)}>
-          Quality Inspector
-        </Button>
+      ),
+      size: 90,
+      meta: { align: "right" },
+    },
+  ];
+
+  /* --------------------- Render --------------------- */
+
+  return (
+    <>
+      <PageHeader
+        icon={ListChecks}
+        breadcrumbs={[
+          { label: "Dashboard", to: "/" },
+          { label: projectName, to: `/sources/${projectName}` },
+          { label: "Claim Review" },
+        ]}
+        title="Claim Review"
+        description={
+          project &&
+          `${project.name} · 후보·승인·반려 상태 분리 검토 · ${counts.total.toLocaleString()} claims`
+        }
+        actions={
+          <Button onClick={() => navigate(`/quality/${projectName}`)}>
+            <ShieldCheck className="h-4 w-4" />
+            Quality Inspector
+          </Button>
+        }
+      />
+
+      <div className="mx-auto max-w-7xl px-6 py-6">
+        {claims.isError && (
+          <ErrorState
+            className="mb-4"
+            inline
+            severity="error"
+            title="Failed to load claims"
+            description={claims.error as Error}
+            onRetry={() => claims.refetch()}
+          />
+        )}
+
+        {/* Metrics */}
+        <div className="mb-4 grid gap-3 sm:grid-cols-2 lg:grid-cols-4">
+          <Metric label="Total" value={counts.total} tone="muted" />
+          <Metric label="Candidate" value={counts.candidate} tone="warning" />
+          <Metric label="Approved" value={counts.approved} tone="success" />
+          <Metric label="Rejected" value={counts.rejected} tone="danger" />
+        </div>
+
+        {/* Filter panel */}
+        <FilterPanel
+          className="mb-4"
+          chips={chips.length > 0 ? <FilterChips chips={chips} /> : undefined}
+          onClearAll={chips.length > 0 ? clearAll : undefined}
+        >
+          <FilterSearch
+            value={search}
+            onChange={setSearch}
+            placeholder="Search subject, predicate, object, evidence…"
+          />
+          <FilterSelect
+            label="Status"
+            value={statusFilter}
+            onChange={setStatusFilter}
+            placeholder="All statuses"
+            options={[
+              { value: "candidate", label: "Candidate", hint: counts.candidate, swatch: "hsl(var(--warning))" },
+              { value: "approved", label: "Approved", hint: counts.approved, swatch: "hsl(var(--success))" },
+              { value: "rejected", label: "Rejected", hint: counts.rejected, swatch: "hsl(var(--danger))" },
+            ]}
+          />
+        </FilterPanel>
+
+        <DataTable<Claim>
+          tableId="review"
+          columns={columns}
+          data={filteredClaims}
+          getRowId={(row) => row.id}
+          loading={claims.isLoading}
+          loadingRows={8}
+          height={640}
+          onRowClick={openDetail}
+          rowToneAccessor={(row) => {
+            const r = reviewLabel(row.status);
+            if (r === "approved") return "success";
+            if (r === "rejected") return "danger";
+            return undefined;
+          }}
+          empty={
+            <EmptyState
+              icon={ListChecks}
+              title="조건에 맞는 클레임이 없습니다"
+              description="필터를 조정하거나 클레임을 추가하세요."
+              primaryAction={
+                chips.length > 0 ? (
+                  <Button variant="outline" onClick={clearAll}>
+                    Clear filters
+                  </Button>
+                ) : undefined
+              }
+            />
+          }
+        />
       </div>
 
-      {claims.isError && (
-        <Card className="mb-6 border-destructive">
-          <CardContent className="flex items-center gap-2 py-4 text-sm text-destructive">
-            <AlertCircle className="h-4 w-4" />
-            {(claims.error as Error).message}
-          </CardContent>
-        </Card>
-      )}
-
-      <div className="mb-6 grid gap-4 md:grid-cols-4">
-        <Metric label="Total" value={counts.total} />
-        <Metric label="Candidate" value={counts.candidate} />
-        <Metric label="Approved" value={counts.approved} />
-        <Metric label="Rejected" value={counts.rejected} />
-      </div>
-
-      <div className="grid gap-6 xl:grid-cols-[minmax(0,1fr)_420px]">
-        <Card className="min-w-0">
-          <CardHeader>
-            <div className="flex flex-wrap items-end justify-between gap-3">
-              <div className="min-w-0">
-                <CardTitle>Review Queue</CardTitle>
-                <CardDescription>
-                  신뢰도, 출처, 생성 방식, 검증 결과를 함께 확인합니다.
-                </CardDescription>
+      {/* Detail Drawer */}
+      <Drawer
+        open={drawerOpen && !!selectedClaim}
+        onOpenChange={(open) => {
+          setDrawerOpen(open);
+          if (!open) setSelectedId(null);
+        }}
+        size="lg"
+        title={
+          selectedClaim
+            ? `Claim #${selectedClaim.id} · ${selectedClaim.predicate}`
+            : ""
+        }
+        description="근거, 출처, 검증 결과, 히스토리"
+        headerExtra={
+          selectedClaim ? (
+            <Badge variant={statusVariant(selectedClaim.status)}>
+              {reviewLabel(selectedClaim.status)}
+            </Badge>
+          ) : null
+        }
+        footer={
+          selectedClaim ? (
+            <>
+              <Button
+                variant="outline"
+                onClick={() => applyStatus(selectedClaim, "rejected")}
+                disabled={updateStatus.isPending}
+              >
+                <X className="h-4 w-4" />
+                Reject
+              </Button>
+              <Button
+                onClick={() => applyStatus(selectedClaim, "validated_claim")}
+                disabled={updateStatus.isPending}
+              >
+                <Check className="h-4 w-4" />
+                Approve
+              </Button>
+            </>
+          ) : null
+        }
+      >
+        {selectedClaim && (
+          <div className="space-y-5">
+            {/* Triple summary */}
+            <div className="rounded-md border border-border bg-background-subtle p-3">
+              <div className="flex flex-wrap items-center gap-2 text-sm">
+                <span className="font-medium text-foreground">
+                  {humanizeValue(selectedClaim.subject)}
+                </span>
+                {selectedClaim.subject_type && (
+                  <span className="pill-muted">
+                    {selectedClaim.subject_type}
+                  </span>
+                )}
+                <ArrowRight className="h-3.5 w-3.5 text-muted-foreground" />
+                <Badge variant="secondary" className="font-mono">
+                  {selectedClaim.predicate}
+                </Badge>
+                <ArrowRight className="h-3.5 w-3.5 text-muted-foreground" />
+                <span className="font-medium text-foreground">
+                  {claimObjectText(selectedClaim)}
+                </span>
               </div>
-              <div className="flex flex-wrap gap-2">
-                <div className="relative">
-                  <Search className="pointer-events-none absolute left-3 top-2.5 h-4 w-4 text-muted-foreground" />
-                  <Input
-                    value={search}
-                    onChange={(event) => setSearch(event.target.value)}
-                    className="w-48 pl-9 sm:w-56"
-                    placeholder="Search claims"
-                  />
-                </div>
-                <div className="relative">
-                  <Filter className="pointer-events-none absolute left-3 top-2.5 h-4 w-4 text-muted-foreground" />
-                  <Select
-                    value={statusFilter}
-                    onChange={(event) => setStatusFilter(event.target.value)}
-                    className="w-32 pl-9 sm:w-40"
-                  >
-                    <option value="all">All</option>
-                    <option value="candidate">Candidate</option>
-                    <option value="approved">Approved</option>
-                    <option value="rejected">Rejected</option>
-                  </Select>
-                </div>
+              <div className="mt-2 flex flex-wrap gap-3 text-2xs text-muted-foreground">
+                <span>
+                  Confidence{" "}
+                  <span className="font-medium text-foreground tabular-nums">
+                    {formatPercent(selectedClaim.confidence)}
+                  </span>
+                </span>
+                <span>
+                  Bucket{" "}
+                  <span className="font-medium text-foreground">
+                    {confidenceBucket(selectedClaim)}
+                  </span>
+                </span>
+                {selectedClaim.review_required && (
+                  <span className="pill-warning">review required</span>
+                )}
               </div>
             </div>
-          </CardHeader>
-          <CardContent>
-            {claims.isLoading && (
-              <div className="space-y-3">
-                {Array.from({ length: 5 }).map((_, index) => (
-                  <Skeleton key={index} className="h-24" />
-                ))}
-              </div>
-            )}
-            {!claims.isLoading && filteredClaims.length === 0 && (
-              <p className="py-10 text-center text-sm text-muted-foreground">
-                조건에 맞는 클레임이 없습니다.
-              </p>
-            )}
-            <div className="space-y-3">
-              {filteredClaims.map((claim) => {
-                const isSelected = selectedClaim?.id === claim.id;
-                return (
-                  <article
-                    key={claim.id}
-                    className={cn(
-                      "rounded-md border bg-surface transition-colors",
-                      isSelected
-                        ? "border-brand-500 ring-1 ring-brand-500/30"
-                        : "border-border hover:border-border-strong",
-                    )}
-                  >
-                    <button
-                      type="button"
-                      onClick={() => setSelectedId(claim.id)}
-                      className="block w-full px-4 pt-4 pb-3 text-left"
-                    >
-                      <div className="mb-2 flex flex-wrap items-center gap-1.5">
-                        <Badge variant={statusVariant(claim.status)}>
-                          {reviewLabel(claim.status)}
-                        </Badge>
-                        <Badge variant="secondary">{claim.predicate}</Badge>
-                        <span className="text-2xs text-muted-foreground">
-                          {confidenceBucket(claim)}
-                        </span>
-                      </div>
-                      <div className="flex flex-wrap items-baseline gap-1.5 text-sm">
-                        <span className="break-all font-medium text-foreground">
-                          {humanizeValue(claim.subject)}
-                        </span>
-                        <ArrowRight className="h-3 w-3 flex-shrink-0 text-muted-foreground" />
-                        <span className="break-all font-medium text-foreground">
-                          {claimObject(claim)}
-                        </span>
-                      </div>
-                      <div className="mt-2 flex flex-wrap gap-x-3 gap-y-1 text-2xs text-muted-foreground">
-                        <span>
-                          Confidence{" "}
-                          <span className="font-medium text-foreground tabular-nums">
-                            {formatPercent(claim.confidence)}
-                          </span>
-                        </span>
-                        <span>
-                          Source{" "}
-                          <span className="font-medium text-foreground">
-                            {humanizeValue(claim.source)}
-                          </span>
-                        </span>
-                        <span>
-                          Evidence{" "}
-                          <span
-                            className={
-                              claim.evidence_text
-                                ? "font-medium text-success"
-                                : "font-medium text-warning"
-                            }
-                          >
-                            {claim.evidence_text ? "yes" : "missing"}
-                          </span>
-                        </span>
-                        <span>
-                          Method{" "}
-                          <span className="font-medium text-foreground">
-                            {humanizeValue(claim.extraction_method)}
-                          </span>
-                        </span>
-                      </div>
-                    </button>
-                    <div className="flex flex-wrap items-center justify-end gap-1.5 border-t border-border bg-background-subtle px-3 py-2">
-                      <Button
-                        variant="ghost"
-                        size="sm"
-                        onClick={() => setSelectedId(claim.id)}
-                      >
-                        <Eye className="h-3.5 w-3.5" />
-                        Detail
-                      </Button>
-                      <Button
-                        variant="outline"
-                        size="sm"
-                        onClick={() => applyStatus(claim, "validated_claim")}
-                        disabled={updateStatus.isPending}
-                      >
-                        <Check className="h-3.5 w-3.5" />
-                        Approve
-                      </Button>
-                      <Button
-                        variant="outline"
-                        size="sm"
-                        onClick={() => applyStatus(claim, "rejected")}
-                        disabled={updateStatus.isPending}
-                      >
-                        <X className="h-3.5 w-3.5" />
-                        Reject
-                      </Button>
-                    </div>
-                  </article>
-                );
-              })}
-            </div>
-          </CardContent>
-        </Card>
 
-        <aside className="xl:sticky xl:top-4 xl:self-start">
-          <Card>
-            <CardHeader>
-              <CardTitle>Claim Detail</CardTitle>
-              <CardDescription>
-                근거, 출처, 검증 결과, 히스토리
-              </CardDescription>
-            </CardHeader>
-            <CardContent>
-              {!selectedClaim && (
-                <p className="py-8 text-center text-sm text-muted-foreground">
-                  클레임을 선택하세요.
-                </p>
-              )}
-              {selectedClaim && (
-                <div className="space-y-4">
-                  <div className="flex flex-wrap gap-2">
-                    <Badge variant={statusVariant(selectedClaim.status)}>
-                      {reviewLabel(selectedClaim.status)}
-                    </Badge>
-                    <Badge variant="outline">
-                      {formatPercent(selectedClaim.confidence)}
-                    </Badge>
-                    {selectedClaim.review_required && (
-                      <Badge variant="warning">review required</Badge>
-                    )}
-                  </div>
-                  <DetailRow label="Subject" value={selectedClaim.subject} />
-                  <DetailRow label="Subject Type" value={selectedClaim.subject_type} />
-                  <DetailRow label="Predicate" value={selectedClaim.predicate} />
-                  <DetailRow
-                    label="Object"
-                    value={selectedClaim.object ?? selectedClaim.object_value}
-                  />
-                  <DetailRow label="Source" value={selectedClaim.source} />
-                  <DetailRow label="Source URL" value={selectedClaim.page_url} />
-                  <DetailRow
-                    label="Page Type"
-                    value={selectedClaim.page_type}
-                  />
-                  <DetailRow
-                    label="Created By"
-                    value={selectedClaim.extraction_method}
-                  />
-                  <DetailRow
-                    label="Validation"
-                    value={
-                      selectedClaim.validation_status ??
-                      selectedClaim.graph_merge_status
-                    }
-                  />
-                  {selectedClaim.graph_merge_reason && (
-                    <DetailRow
-                      label="Graph Reason"
-                      value={selectedClaim.graph_merge_reason}
-                    />
-                  )}
-                  {selectedClaim.evidence_text && (
-                    <section>
-                      <h3 className="mb-2 text-sm font-medium">Evidence Text</h3>
-                      <div className="rounded-md bg-yellow-50 px-3 py-2 text-sm leading-relaxed text-yellow-950">
-                        {selectedClaim.evidence_text}
-                      </div>
-                    </section>
-                  )}
-                  {selectedClaim.confidence_breakdown && (
-                    <section>
-                      <h3 className="mb-2 text-sm font-medium">
-                        Confidence Breakdown
-                      </h3>
-                      <pre className="max-h-44 overflow-auto rounded-md bg-secondary/30 p-3 text-xs">
-                        {JSON.stringify(
-                          selectedClaim.confidence_breakdown,
-                          null,
-                          2,
-                        )}
-                      </pre>
-                    </section>
-                  )}
-                  {selectedClaim.source_history &&
-                    selectedClaim.source_history.length > 0 && (
-                      <section>
-                        <h3 className="mb-2 text-sm font-medium">
-                          Source History
-                        </h3>
-                        <pre className="max-h-44 overflow-auto rounded-md bg-secondary/30 p-3 text-xs">
-                          {JSON.stringify(selectedClaim.source_history, null, 2)}
-                        </pre>
-                      </section>
-                    )}
-                  <div className="grid grid-cols-2 gap-2 pt-2">
-                    <Button
-                      onClick={() =>
-                        applyStatus(selectedClaim, "validated_claim")
-                      }
-                      disabled={updateStatus.isPending}
+            {/* Detail grid */}
+            <div className="grid gap-3 sm:grid-cols-2">
+              <DetailRow label="Source" value={selectedClaim.source} />
+              <DetailRow
+                label="Page Type"
+                value={selectedClaim.page_type}
+              />
+              <DetailRow
+                label="Extraction Method"
+                value={selectedClaim.extraction_method}
+              />
+              <DetailRow
+                label="Validation"
+                value={
+                  selectedClaim.validation_status ??
+                  selectedClaim.graph_merge_status
+                }
+              />
+              {selectedClaim.page_url && (
+                <DetailRow
+                  label="Source URL"
+                  value={
+                    <a
+                      href={selectedClaim.page_url}
+                      target="_blank"
+                      rel="noopener noreferrer"
+                      className="inline-flex items-center gap-1 text-brand-600 hover:underline dark:text-brand-300"
                     >
-                      <Check className="h-4 w-4" />
-                      Approve
-                    </Button>
-                    <Button
-                      variant="outline"
-                      onClick={() => applyStatus(selectedClaim, "rejected")}
-                      disabled={updateStatus.isPending}
-                    >
-                      <X className="h-4 w-4" />
-                      Reject
-                    </Button>
-                  </div>
-                  <div className="text-xs text-muted-foreground">
-                    Last seen {formatDateTime(selectedClaim.last_seen_at)}
-                  </div>
-                </div>
+                      <ExternalLink className="h-3 w-3" />
+                      <span className="max-w-[240px] truncate">
+                        {selectedClaim.page_url}
+                      </span>
+                    </a>
+                  }
+                  full
+                />
               )}
-            </CardContent>
-          </Card>
-        </aside>
-      </div>
-    </div>
+              {selectedClaim.graph_merge_reason && (
+                <DetailRow
+                  label="Graph Reason"
+                  value={selectedClaim.graph_merge_reason}
+                  full
+                />
+              )}
+            </div>
+
+            {/* Evidence */}
+            {selectedClaim.evidence_text && (
+              <section>
+                <h3 className="mb-1.5 text-2xs font-semibold uppercase tracking-wider text-muted-foreground">
+                  Evidence Text
+                </h3>
+                <blockquote className="rounded-md border-l-4 border-warning bg-warning-subtle px-3 py-2 text-sm leading-relaxed text-foreground">
+                  {selectedClaim.evidence_text}
+                </blockquote>
+              </section>
+            )}
+
+            {/* Confidence breakdown */}
+            {selectedClaim.confidence_breakdown && (
+              <section>
+                <h3 className="mb-1.5 text-2xs font-semibold uppercase tracking-wider text-muted-foreground">
+                  Confidence Breakdown
+                </h3>
+                <pre className="max-h-44 overflow-auto rounded-md border border-border bg-background-subtle p-3 text-2xs">
+                  {JSON.stringify(
+                    selectedClaim.confidence_breakdown,
+                    null,
+                    2,
+                  )}
+                </pre>
+              </section>
+            )}
+
+            {/* Source history */}
+            {selectedClaim.source_history &&
+              selectedClaim.source_history.length > 0 && (
+                <section>
+                  <h3 className="mb-1.5 text-2xs font-semibold uppercase tracking-wider text-muted-foreground">
+                    Source History ({selectedClaim.source_history.length})
+                  </h3>
+                  <pre className="max-h-44 overflow-auto rounded-md border border-border bg-background-subtle p-3 text-2xs">
+                    {JSON.stringify(selectedClaim.source_history, null, 2)}
+                  </pre>
+                </section>
+              )}
+
+            <div className="border-t border-border pt-3 text-2xs text-muted-foreground">
+              Last seen {formatDateTime(selectedClaim.last_seen_at)}
+            </div>
+          </div>
+        )}
+      </Drawer>
+    </>
   );
 }
 
-function Metric({ label, value }: { label: string; value: number }) {
+/* ============================================================
+ * Sub-components
+ * ========================================================== */
+
+const METRIC_TONE: Record<string, string> = {
+  muted: "border-border",
+  warning: "border-warning-border bg-warning-subtle/30",
+  success: "border-success-border bg-success-subtle/30",
+  danger: "border-danger-border bg-danger-subtle/30",
+};
+
+function Metric({
+  label,
+  value,
+  tone = "muted",
+}: {
+  label: string;
+  value: number;
+  tone?: keyof typeof METRIC_TONE;
+}) {
   return (
-    <Card>
-      <CardContent className="py-4">
-        <div className="text-xs text-muted-foreground">{label}</div>
-        <div className="mt-1 text-2xl font-semibold">
+    <Card className={`border ${METRIC_TONE[tone]}`}>
+      <CardContent className="py-3">
+        <div className="text-2xs uppercase tracking-wider text-muted-foreground">
+          {label}
+        </div>
+        <div className="mt-1 text-2xl font-semibold tabular-nums text-foreground">
           {value.toLocaleString()}
         </div>
       </CardContent>
@@ -458,11 +626,48 @@ function Metric({ label, value }: { label: string; value: number }) {
   );
 }
 
-function DetailRow({ label, value }: { label: string; value: unknown }) {
+function ConfidenceBar({ value }: { value: number | undefined }) {
+  if (typeof value !== "number") {
+    return <span className="text-xs text-muted-foreground/60">—</span>;
+  }
+  const pct = Math.round(value * 100);
+  const tone =
+    value >= 0.9
+      ? "bg-success"
+      : value >= 0.7
+        ? "bg-info"
+        : value >= 0.5
+          ? "bg-warning"
+          : "bg-danger";
   return (
-    <div className="rounded-md border bg-background px-3 py-2 text-sm">
-      <div className="text-xs text-muted-foreground">{label}</div>
-      <div className="mt-1 break-words font-medium">{humanizeValue(value)}</div>
+    <div className="flex items-center justify-end gap-2">
+      <div className="h-1.5 w-14 overflow-hidden rounded-full bg-muted">
+        <div className={`h-full ${tone}`} style={{ width: `${pct}%` }} />
+      </div>
+      <span className="text-xs tabular-nums text-foreground">{pct}%</span>
+    </div>
+  );
+}
+
+function DetailRow({
+  label,
+  value,
+  full = false,
+}: {
+  label: string;
+  value: unknown;
+  full?: boolean;
+}) {
+  return (
+    <div
+      className={`rounded-md border border-border bg-background-subtle px-3 py-2 ${full ? "sm:col-span-2" : ""}`}
+    >
+      <div className="text-2xs uppercase tracking-wider text-muted-foreground">
+        {label}
+      </div>
+      <div className="mt-1 break-words text-sm font-medium text-foreground">
+        {React.isValidElement(value) ? value : humanizeValue(value)}
+      </div>
     </div>
   );
 }