Merge pull request 'Tree view: add "Back to default person" recenter link' (#36) from add-default-person-link into main

Once you recenter the tree on someone, there was no quick way back to the
tree's home/default person. Add a header link (shown only when a home person
is set and you're not already on them) that recenters the chart on
home_person_id via the existing goTo() — works in landscape, portrait, and
fan modes. Labels with the home person's name for clarity.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Justin Paul <justin@jpaul.me>

backend/Dockerfile

@@ -21,7 +21,11 @@ RUN --mount=type=cache,target=/root/.cache/uv \
 COPY app ./app
 COPY alembic.ini ./alembic.ini
 COPY migrations ./migrations
+COPY docker-entrypoint.sh ./docker-entrypoint.sh
+RUN chmod +x ./docker-entrypoint.sh
 
 EXPOSE 8000
 
+# The entrypoint runs migrations first when RUN_MIGRATIONS=1, then the command.
+ENTRYPOINT ["./docker-entrypoint.sh"]
 CMD ["uv", "run", "--no-dev", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

backend/app/api/v1/__init__.py

@@ -5,9 +5,11 @@ from fastapi import APIRouter
 from app.api.v1 import (
     auth,
     citations,
+    cleanup,
     events,
     gedcom,
     media,
+    names,
     persons,
     relationships,
     sources,
@@ -20,9 +22,11 @@ api_router.include_router(auth.router)
 api_router.include_router(users.router)
 api_router.include_router(trees.router)
 api_router.include_router(persons.router)
+api_router.include_router(names.router)
 api_router.include_router(events.router)
 api_router.include_router(relationships.router)
 api_router.include_router(sources.router)
 api_router.include_router(citations.router)
 api_router.include_router(media.router)
 api_router.include_router(gedcom.router)
+api_router.include_router(cleanup.router)

backend/app/api/v1/auth.py

@@ -1,9 +1,10 @@
 from fastapi import APIRouter, HTTPException, Request, Response, status
 
-from app.api.deps import MailerDep, SessionDep, extract_session_token
+from app.api.deps import CurrentUser, MailerDep, SessionDep, extract_session_token
 from app.core.config import get_settings
 from app.schemas.auth import (
     LoginRequest,
+    PasswordChange,
     PasswordResetConfirm,
     PasswordResetRequest,
     RegisterRequest,
@@ -79,3 +80,15 @@ async def reset_password(data: PasswordResetConfirm, session: SessionDep) -> Non
     await auth_service.reset_password(
         session, raw_token=data.token, new_password=data.new_password
     )
+
+
+@router.post("/change-password", status_code=status.HTTP_204_NO_CONTENT)
+async def change_password(
+    data: PasswordChange, session: SessionDep, current: CurrentUser
+) -> None:
+    await auth_service.change_password(
+        session,
+        user=current,
+        current_password=data.current_password,
+        new_password=data.new_password,
+    )

backend/app/api/v1/citations.py

@@ -3,7 +3,7 @@ import uuid
 from fastapi import APIRouter, status
 
 from app.api.deps import CurrentUser, SessionDep
-from app.schemas.source import CitationCreate, CitationRead
+from app.schemas.source import CitationCreate, CitationRead, CitationUpdate
 from app.services import citation_service, tree_service
 
 router = APIRouter(prefix="/trees", tags=["citations"])
@@ -31,6 +31,25 @@ async def list_citations(
     return [CitationRead.model_validate(c) for c in citations]
 
 
+@router.patch("/{tree_id}/citations/{citation_id}", response_model=CitationRead)
+async def update_citation(
+    tree_id: uuid.UUID,
+    citation_id: uuid.UUID,
+    data: CitationUpdate,
+    session: SessionDep,
+    current: CurrentUser,
+) -> CitationRead:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    citation = await citation_service.update_citation(
+        session,
+        actor=current,
+        tree=tree,
+        citation_id=citation_id,
+        changes=data.model_dump(exclude_unset=True),
+    )
+    return CitationRead.model_validate(citation)
+
+
 @router.delete("/{tree_id}/citations/{citation_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_citation(
     tree_id: uuid.UUID, citation_id: uuid.UUID, session: SessionDep, current: CurrentUser

backend/app/api/v1/cleanup.py

@@ -0,0 +1,101 @@
+import uuid
+
+from fastapi import APIRouter, File, UploadFile
+
+from app.api.deps import CurrentUser, SessionDep
+from app.schemas.cleanup import (
+    CleanupResult,
+    DeceasedApply,
+    DeceasedCandidate,
+    GenderApply,
+    GenderProposal,
+    NameApply,
+    NameIssue,
+)
+from app.services import cleanup_service, tree_service
+
+router = APIRouter(prefix="/trees", tags=["cleanup"])
+
+
+@router.get("/{tree_id}/cleanup/deceased", response_model=list[DeceasedCandidate])
+async def preview_deceased(
+    tree_id: uuid.UUID,
+    session: SessionDep,
+    current: CurrentUser,
+    born_on_or_before: int = 1930,
+) -> list[DeceasedCandidate]:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    rows = await cleanup_service.preview_deceased(
+        session, actor=current, tree=tree, year=born_on_or_before
+    )
+    return [DeceasedCandidate(**r) for r in rows]
+
+
+@router.post("/{tree_id}/cleanup/deceased", response_model=CleanupResult)
+async def apply_deceased(
+    tree_id: uuid.UUID, data: DeceasedApply, session: SessionDep, current: CurrentUser
+) -> CleanupResult:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    n = await cleanup_service.apply_deceased(
+        session, actor=current, tree=tree, person_ids=data.person_ids
+    )
+    return CleanupResult(updated=n)
+
+
+@router.post("/{tree_id}/cleanup/gender/preview", response_model=list[GenderProposal])
+async def preview_gender(
+    tree_id: uuid.UUID,
+    session: SessionDep,
+    current: CurrentUser,
+    file: UploadFile = File(...),
+) -> list[GenderProposal]:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    text = (await file.read()).decode("utf-8", errors="replace")
+    rows = await cleanup_service.preview_gender(
+        session, actor=current, tree=tree, gedcom_text=text
+    )
+    return [GenderProposal(**r) for r in rows]
+
+
+@router.get("/{tree_id}/cleanup/gender/guess", response_model=list[GenderProposal])
+async def guess_gender(
+    tree_id: uuid.UUID, session: SessionDep, current: CurrentUser
+) -> list[GenderProposal]:
+    """Best-guess sex from first names (bundled dictionary) for people missing it."""
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    rows = await cleanup_service.guess_gender_by_name(session, actor=current, tree=tree)
+    return [GenderProposal(**r) for r in rows]
+
+
+@router.post("/{tree_id}/cleanup/gender", response_model=CleanupResult)
+async def apply_gender(
+    tree_id: uuid.UUID, data: GenderApply, session: SessionDep, current: CurrentUser
+) -> CleanupResult:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    n = await cleanup_service.apply_gender(
+        session,
+        actor=current,
+        tree=tree,
+        updates=[u.model_dump() for u in data.updates],
+    )
+    return CleanupResult(updated=n)
+
+
+@router.get("/{tree_id}/cleanup/names", response_model=list[NameIssue])
+async def preview_names(
+    tree_id: uuid.UUID, session: SessionDep, current: CurrentUser
+) -> list[NameIssue]:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    rows = await cleanup_service.preview_names(session, actor=current, tree=tree)
+    return [NameIssue(**r) for r in rows]
+
+
+@router.post("/{tree_id}/cleanup/names", response_model=CleanupResult)
+async def apply_names(
+    tree_id: uuid.UUID, data: NameApply, session: SessionDep, current: CurrentUser
+) -> CleanupResult:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    n = await cleanup_service.apply_names(
+        session, actor=current, tree=tree, edits=[e.model_dump() for e in data.edits]
+    )
+    return CleanupResult(updated=n)

backend/app/api/v1/gedcom.py

@@ -1,25 +1,56 @@
+import json
 import uuid
 
-from fastapi import APIRouter, File, Response, UploadFile
+from fastapi import APIRouter, File, Form, Response, UploadFile
 
 from app.api.deps import CurrentUser, SessionDep
-from app.schemas.gedcom import ImportReport
+from app.schemas.gedcom import ImportPreview, ImportReport
 from app.services import gedcom, tree_service
 
 router = APIRouter(prefix="/trees", tags=["gedcom"])
 
 
+@router.post("/{tree_id}/gedcom/preview", response_model=ImportPreview)
+async def preview_gedcom(
+    tree_id: uuid.UUID,
+    session: SessionDep,
+    current: CurrentUser,
+    file: UploadFile = File(...),
+) -> ImportPreview:
+    """Dry run: report counts and incoming people that look like duplicates of
+    existing ones, so the user can choose how to resolve each before importing."""
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    text = (await file.read()).decode("utf-8", errors="replace")
+    report = await gedcom.preview_gedcom(session, actor=current, tree=tree, text=text)
+    return ImportPreview(**report)
+
+
 @router.post("/{tree_id}/gedcom/import", response_model=ImportReport)
 async def import_gedcom(
     tree_id: uuid.UUID,
     session: SessionDep,
     current: CurrentUser,
     file: UploadFile = File(...),
+    default_action: str = Form("new"),
+    resolutions: str = Form("{}"),
 ) -> ImportReport:
-    # NOTE: additive — records are created as new; existing people are not merged.
+    """Import a GEDCOM. ``default_action`` (new|skip|merge|overwrite) applies to
+    incoming people that match an existing one; ``resolutions`` is a JSON object
+    {xref: {action, target_id}} overriding it per record."""
     tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
     text = (await file.read()).decode("utf-8", errors="replace")
-    report = await gedcom.import_gedcom(session, actor=current, tree=tree, text=text)
+    try:
+        parsed = json.loads(resolutions or "{}")
+    except json.JSONDecodeError:
+        parsed = {}
+    report = await gedcom.import_gedcom(
+        session,
+        actor=current,
+        tree=tree,
+        text=text,
+        default_action=default_action,
+        resolutions=parsed,
+    )
     return ImportReport(**report)
 
 

backend/app/api/v1/media.py

@@ -3,7 +3,7 @@ import uuid
 from fastapi import APIRouter, File, Form, Response, UploadFile, status
 
 from app.api.deps import CurrentUser, ObjectStoreDep, SessionDep
-from app.schemas.media import MediaRead
+from app.schemas.media import MediaRead, MediaUpdate
 from app.services import media_service, tree_service
 
 
@@ -81,6 +81,26 @@ async def media_content(
     )
 
 
+@router.patch("/{tree_id}/media/{media_id}", response_model=MediaRead)
+async def update_media(
+    tree_id: uuid.UUID,
+    media_id: uuid.UUID,
+    data: MediaUpdate,
+    session: SessionDep,
+    current: CurrentUser,
+    store: ObjectStoreDep,
+) -> MediaRead:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    media = await media_service.update_media(
+        session,
+        actor=current,
+        tree=tree,
+        media_id=media_id,
+        changes=data.model_dump(exclude_unset=True),
+    )
+    return _read(media)
+
+
 @router.delete("/{tree_id}/media/{media_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_media(
     tree_id: uuid.UUID, media_id: uuid.UUID, session: SessionDep, current: CurrentUser

backend/app/api/v1/names.py

@@ -0,0 +1,90 @@
+import uuid
+
+from fastapi import APIRouter, status
+
+from app.api.deps import CurrentUser, SessionDep
+from app.schemas.name import NameCreate, NameRead, NameUpdate
+from app.services import name_service, tree_service
+
+# Names are nested under their person (which is nested under the tree tenant).
+router = APIRouter(prefix="/trees", tags=["names"])
+
+
+@router.get("/{tree_id}/persons/{person_id}/names", response_model=list[NameRead])
+async def list_names(
+    tree_id: uuid.UUID, person_id: uuid.UUID, session: SessionDep, current: CurrentUser
+) -> list[NameRead]:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    names = await name_service.list_names(
+        session, viewer_id=current.id, tree=tree, person_id=person_id
+    )
+    return [NameRead.model_validate(n) for n in names]
+
+
+@router.post(
+    "/{tree_id}/persons/{person_id}/names",
+    response_model=NameRead,
+    status_code=status.HTTP_201_CREATED,
+)
+async def create_name(
+    tree_id: uuid.UUID,
+    person_id: uuid.UUID,
+    data: NameCreate,
+    session: SessionDep,
+    current: CurrentUser,
+) -> NameRead:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    name = await name_service.create_name(
+        session,
+        actor=current,
+        tree=tree,
+        person_id=person_id,
+        name_type=data.name_type,
+        given=data.given,
+        surname=data.surname,
+        prefix=data.prefix,
+        suffix=data.suffix,
+        nickname=data.nickname,
+        is_primary=data.is_primary,
+    )
+    return NameRead.model_validate(name)
+
+
+@router.patch(
+    "/{tree_id}/persons/{person_id}/names/{name_id}", response_model=NameRead
+)
+async def update_name(
+    tree_id: uuid.UUID,
+    person_id: uuid.UUID,
+    name_id: uuid.UUID,
+    data: NameUpdate,
+    session: SessionDep,
+    current: CurrentUser,
+) -> NameRead:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    name = await name_service.update_name(
+        session,
+        actor=current,
+        tree=tree,
+        person_id=person_id,
+        name_id=name_id,
+        changes=data.model_dump(exclude_unset=True),
+    )
+    return NameRead.model_validate(name)
+
+
+@router.delete(
+    "/{tree_id}/persons/{person_id}/names/{name_id}",
+    status_code=status.HTTP_204_NO_CONTENT,
+)
+async def delete_name(
+    tree_id: uuid.UUID,
+    person_id: uuid.UUID,
+    name_id: uuid.UUID,
+    session: SessionDep,
+    current: CurrentUser,
+) -> None:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    await name_service.delete_name(
+        session, actor=current, tree=tree, person_id=person_id, name_id=name_id
+    )

backend/app/api/v1/persons.py

@@ -75,12 +75,21 @@ async def update_person(
     return PersonRead.model_validate(person)
 
 
-@router.delete("/{tree_id}/persons/{person_id}", status_code=status.HTTP_204_NO_CONTENT)
+@router.delete("/{tree_id}/persons/{person_id}")
 async def delete_person(
-    tree_id: uuid.UUID, person_id: uuid.UUID, session: SessionDep, current: CurrentUser
+    tree_id: uuid.UUID,
-) -> None:
+    person_id: uuid.UUID,
+    session: SessionDep,
+    current: CurrentUser,
+    cascade: bool = False,
+) -> dict[str, int]:
+    """Delete a person. ``cascade=true`` also deletes all descendants. Returns
+    the number of persons deleted (1 unless cascading)."""
     tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
-    await person_service.delete_person(session, actor=current, tree=tree, person_id=person_id)
+    deleted = await person_service.delete_person(
+        session, actor=current, tree=tree, person_id=person_id, cascade=cascade
+    )
+    return {"deleted": deleted}
 
 
 @router.post("/{tree_id}/persons/{person_id}/restore", response_model=PersonRead)

backend/app/api/v1/relationships.py

@@ -3,7 +3,7 @@ import uuid
 from fastapi import APIRouter, status
 
 from app.api.deps import CurrentUser, SessionDep
-from app.schemas.relationship import RelationshipCreate, RelationshipRead
+from app.schemas.relationship import RelationshipCreate, RelationshipRead, RelationshipUpdate
 from app.services import relationship_service, tree_service
 
 router = APIRouter(prefix="/trees", tags=["relationships"])
@@ -47,6 +47,25 @@ async def list_person_relationships(
     return [RelationshipRead.model_validate(r) for r in rels]
 
 
+@router.patch("/{tree_id}/relationships/{relationship_id}", response_model=RelationshipRead)
+async def update_relationship(
+    tree_id: uuid.UUID,
+    relationship_id: uuid.UUID,
+    data: RelationshipUpdate,
+    session: SessionDep,
+    current: CurrentUser,
+) -> RelationshipRead:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    rel = await relationship_service.update_relationship(
+        session,
+        actor=current,
+        tree=tree,
+        relationship_id=relationship_id,
+        changes=data.model_dump(exclude_unset=True),
+    )
+    return RelationshipRead.model_validate(rel)
+
+
 @router.delete(
     "/{tree_id}/relationships/{relationship_id}", status_code=status.HTTP_204_NO_CONTENT
 )

backend/app/api/v1/sources.py

@@ -3,7 +3,7 @@ import uuid
 from fastapi import APIRouter, status
 
 from app.api.deps import CurrentUser, SessionDep
-from app.schemas.source import SourceCreate, SourceRead
+from app.schemas.source import SourceCreate, SourceRead, SourceUpdate
 from app.services import source_service, tree_service
 
 router = APIRouter(prefix="/trees", tags=["sources"])
@@ -40,6 +40,25 @@ async def get_source(
     return SourceRead.model_validate(source)
 
 
+@router.patch("/{tree_id}/sources/{source_id}", response_model=SourceRead)
+async def update_source(
+    tree_id: uuid.UUID,
+    source_id: uuid.UUID,
+    data: SourceUpdate,
+    session: SessionDep,
+    current: CurrentUser,
+) -> SourceRead:
+    tree = await tree_service.get_tree(session, viewer_id=current.id, tree_id=tree_id)
+    source = await source_service.update_source(
+        session,
+        actor=current,
+        tree=tree,
+        source_id=source_id,
+        changes=data.model_dump(exclude_unset=True),
+    )
+    return SourceRead.model_validate(source)
+
+
 @router.delete("/{tree_id}/sources/{source_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_source(
     tree_id: uuid.UUID, source_id: uuid.UUID, session: SessionDep, current: CurrentUser

backend/app/api/v1/trees.py

@@ -3,7 +3,7 @@ import uuid
 from fastapi import APIRouter, status
 
 from app.api.deps import CurrentUser, SessionDep
-from app.schemas.tree import TreeCreate, TreeRead
+from app.schemas.tree import TreeCreate, TreeRead, TreeUpdate
 from app.services import tree_service
 
 router = APIRouter(prefix="/trees", tags=["trees"])
@@ -38,6 +38,16 @@ async def get_tree(tree_id: uuid.UUID, session: SessionDep, current: CurrentUser
     return TreeRead.model_validate(tree)
 
 
+@router.patch("/{tree_id}", response_model=TreeRead)
+async def update_tree(
+    tree_id: uuid.UUID, data: TreeUpdate, session: SessionDep, current: CurrentUser
+) -> TreeRead:
+    tree = await tree_service.update_tree(
+        session, actor=current, tree_id=tree_id, changes=data.model_dump(exclude_unset=True)
+    )
+    return TreeRead.model_validate(tree)
+
+
 @router.delete("/{tree_id}", status_code=status.HTTP_204_NO_CONTENT)
 async def delete_tree(tree_id: uuid.UUID, session: SessionDep, current: CurrentUser) -> None:
     await tree_service.delete_tree(session, actor=current, tree_id=tree_id)

backend/app/api/v1/users.py

@@ -1,7 +1,8 @@
-from fastapi import APIRouter
+from fastapi import APIRouter, File, Form, Response, UploadFile
 
-from app.api.deps import CurrentUser
+from app.api.deps import CurrentUser, ObjectStoreDep, SessionDep
-from app.schemas.user import UserRead
+from app.schemas.user import UserRead, UserSelfPersonUpdate
+from app.services import account_service, user_service
 
 router = APIRouter(prefix="/users", tags=["users"])
 
@@ -9,3 +10,48 @@ router = APIRouter(prefix="/users", tags=["users"])
 @router.get("/me", response_model=UserRead)
 async def read_me(current: CurrentUser) -> UserRead:
     return UserRead.model_validate(current)
+
+
+@router.patch("/me/self-person", response_model=UserRead)
+async def set_self_person(
+    data: UserSelfPersonUpdate, session: SessionDep, current: CurrentUser
+) -> UserRead:
+    """Link (or unlink) the Person record that represents this account."""
+    user = await user_service.set_self_person(
+        session, user=current, person_id=data.self_person_id
+    )
+    return UserRead.model_validate(user)
+
+
+@router.get("/me/export")
+async def export_account(
+    session: SessionDep, current: CurrentUser, store: ObjectStoreDep
+) -> Response:
+    """Download a full backup (JSON + media) of every tree the user owns."""
+    data = await account_service.export_account(session, store, user=current)
+    return Response(
+        content=data,
+        media_type="application/zip",
+        headers={"Content-Disposition": 'attachment; filename="provenance-export.zip"'},
+    )
+
+
+@router.post("/me/import")
+async def import_account(
+    session: SessionDep,
+    current: CurrentUser,
+    store: ObjectStoreDep,
+    file: UploadFile = File(...),
+) -> dict:
+    """Restore a previously-exported backup into new trees (non-destructive)."""
+    raw = await file.read()
+    return await account_service.import_account(session, store, user=current, raw_zip=raw)
+
+
+@router.delete("/me", status_code=204)
+async def delete_account(
+    session: SessionDep, current: CurrentUser, confirm_email: str = Form(...)
+) -> None:
+    """Delete the account: the user, their owned trees, and their sessions.
+    Requires retyping the account email as a guard."""
+    await account_service.delete_account(session, user=current, confirm_email=confirm_email)

backend/app/models/tree.py

@@ -26,6 +26,16 @@ class Tree(Base, UUIDPrimaryKey, Timestamps, SoftDelete):
         default=TreeVisibility.private,
         server_default=TreeVisibility.private.value,
     )
+    # The person a tree opens focused on (its "home"/root person). Cleared if
+    # that person is deleted. use_alter + name: trees<->persons form an FK cycle.
+    home_person_id: Mapped[uuid.UUID | None] = mapped_column(
+        ForeignKey(
+            "persons.id",
+            ondelete="SET NULL",
+            name="fk_trees_home_person_id",
+            use_alter=True,
+        )
+    )
 
 
 class TreeMembership(Base, UUIDPrimaryKey, Timestamps):

backend/app/models/user.py

@@ -3,9 +3,10 @@ multiple auth providers later (the provider-link table arrives with the auth
 slice). ``hashed_password`` is nullable: external/OIDC users have none.
 """
 
+import uuid
 from datetime import datetime
 
-from sqlalchemy import DateTime, String
+from sqlalchemy import DateTime, ForeignKey, String
 from sqlalchemy.orm import Mapped, mapped_column
 
 from app.models.base import Base
@@ -19,3 +20,15 @@ class User(Base, UUIDPrimaryKey, Timestamps, SoftDelete):
     email_verified_at: Mapped[datetime | None] = mapped_column(DateTime(timezone=True))
     display_name: Mapped[str | None] = mapped_column(String(255))
     hashed_password: Mapped[str | None] = mapped_column(String(255))
+    # The Person record that *is* this user ("home person"). Cleared if that
+    # person is deleted, so the link can never dangle.
+    self_person_id: Mapped[uuid.UUID | None] = mapped_column(
+        # use_alter + explicit name: users<->persons<->trees form an FK cycle,
+        # so this constraint must be created/dropped via ALTER, not inline.
+        ForeignKey(
+            "persons.id",
+            ondelete="SET NULL",
+            name="fk_users_self_person_id",
+            use_alter=True,
+        )
+    )

backend/app/schemas/auth.py

@@ -29,6 +29,11 @@ class PasswordResetConfirm(BaseModel):
     new_password: str = Field(min_length=8)
 
 
+class PasswordChange(BaseModel):
+    current_password: str
+    new_password: str = Field(min_length=8)
+
+
 class SessionRead(BaseModel):
     user: UserRead
     token: str

backend/app/schemas/cleanup.py

@@ -0,0 +1,50 @@
+import uuid
+
+from pydantic import BaseModel
+
+
+class DeceasedCandidate(BaseModel):
+    person_id: uuid.UUID
+    name: str
+    birth_year: int
+
+
+class DeceasedApply(BaseModel):
+    person_ids: list[uuid.UUID]
+
+
+class GenderProposal(BaseModel):
+    person_id: uuid.UUID
+    name: str
+    proposed_gender: str
+
+
+class GenderUpdate(BaseModel):
+    person_id: uuid.UUID
+    gender: str
+
+
+class GenderApply(BaseModel):
+    updates: list[GenderUpdate]
+
+
+class NameIssue(BaseModel):
+    name_id: uuid.UUID
+    person_id: uuid.UUID
+    given: str | None = None
+    surname: str | None = None
+    issue: str
+
+
+class NameEdit(BaseModel):
+    name_id: uuid.UUID
+    given: str | None = None
+    surname: str | None = None
+
+
+class NameApply(BaseModel):
+    edits: list[NameEdit]
+
+
+class CleanupResult(BaseModel):
+    updated: int

backend/app/schemas/gedcom.py

@@ -1,6 +1,25 @@
+import uuid
+
 from pydantic import BaseModel
 
 
 class ImportReport(BaseModel):
     counts: dict[str, int]
     unmapped_tags: list[str]
+
+
+class DuplicateMatch(BaseModel):
+    # An incoming GEDCOM person that resembles an existing one in the tree.
+    xref: str
+    incoming_name: str
+    incoming_birth_year: str | None = None
+    existing_person_id: uuid.UUID
+    existing_name: str
+    existing_birth_year: str | None = None
+    score: str  # "high" | "medium"
+
+
+class ImportPreview(BaseModel):
+    counts: dict[str, int]
+    potential_duplicates: list[DuplicateMatch]
+    unmapped_tags: list[str]

backend/app/schemas/media.py

@@ -4,6 +4,13 @@ from datetime import datetime
 from pydantic import BaseModel, ConfigDict
 
 
+class MediaUpdate(BaseModel):
+    title: str | None = None
+    person_id: uuid.UUID | None = None
+    event_id: uuid.UUID | None = None
+    source_id: uuid.UUID | None = None
+
+
 class MediaRead(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 

backend/app/schemas/name.py

@@ -0,0 +1,42 @@
+import uuid
+from datetime import datetime
+
+from pydantic import BaseModel, ConfigDict
+
+
+class NameCreate(BaseModel):
+    # Open vocabulary: birth/maiden, married, alias, religious, nickname, ...
+    name_type: str = "birth"
+    given: str | None = None
+    surname: str | None = None
+    prefix: str | None = None
+    suffix: str | None = None
+    nickname: str | None = None
+    is_primary: bool = False
+
+
+class NameUpdate(BaseModel):
+    name_type: str | None = None
+    given: str | None = None
+    surname: str | None = None
+    prefix: str | None = None
+    suffix: str | None = None
+    nickname: str | None = None
+    is_primary: bool | None = None
+
+
+class NameRead(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    id: uuid.UUID
+    tree_id: uuid.UUID
+    person_id: uuid.UUID
+    name_type: str
+    given: str | None
+    surname: str | None
+    prefix: str | None
+    suffix: str | None
+    nickname: str | None
+    is_primary: bool
+    sort_order: int
+    created_at: datetime

backend/app/schemas/relationship.py

@@ -15,6 +15,11 @@ class RelationshipCreate(BaseModel):
     notes: str | None = None
 
 
+class RelationshipUpdate(BaseModel):
+    qualifier: ParentChildQualifier | None = None
+    notes: str | None = None
+
+
 class RelationshipRead(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 

backend/app/schemas/source.py

@@ -33,6 +33,23 @@ class SourceRead(BaseModel):
     created_at: datetime
 
 
+class SourceUpdate(BaseModel):
+    title: str | None = None
+    author: str | None = None
+    source_type: str | None = None
+    repository: str | None = None
+    url: str | None = None
+    citation_text: str | None = None
+    publication_info: str | None = None
+    quality_note: str | None = None
+
+
+class CitationUpdate(BaseModel):
+    page: str | None = None
+    detail: str | None = None
+    confidence: CitationConfidence | None = None
+
+
 class CitationCreate(BaseModel):
     source_id: uuid.UUID
     # Exactly one target fact.

backend/app/schemas/tree.py

@@ -12,6 +12,13 @@ class TreeCreate(BaseModel):
     visibility: TreeVisibility = TreeVisibility.private
 
 
+class TreeUpdate(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    visibility: TreeVisibility | None = None
+    home_person_id: uuid.UUID | None = None
+
+
 class TreeRead(BaseModel):
     model_config = ConfigDict(from_attributes=True)
 
@@ -20,4 +27,5 @@ class TreeRead(BaseModel):
     description: str | None
     visibility: TreeVisibility
     owner_id: uuid.UUID
+    home_person_id: uuid.UUID | None = None
     created_at: datetime

backend/app/schemas/user.py

@@ -19,4 +19,10 @@ class UserRead(BaseModel):
     email: str
     display_name: str | None
     email_verified_at: datetime | None
+    self_person_id: uuid.UUID | None = None
     created_at: datetime
+
+
+class UserSelfPersonUpdate(BaseModel):
+    # null clears the link; otherwise the Person that represents this account.
+    self_person_id: uuid.UUID | None = None

backend/app/services/account_service.py

@@ -0,0 +1,352 @@
+"""Account-level data portability: export the signed-in user's owned trees as a
+zip (JSON + media bytes), restore such a zip into a brand-new tree
+(non-destructive), and delete the account.
+
+The export format is a zip containing ``account.json`` plus ``media/<id>`` blobs.
+Restore always creates new trees and remaps ids, so it can't clobber existing
+data.
+"""
+
+import hashlib
+import io
+import json
+import uuid
+import zipfile
+from datetime import UTC, date, datetime
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.integrations.objectstore.base import ObjectStore
+from app.models.auth import Session as SessionModel
+from app.models.enums import MembershipRole
+from app.models.event import Event
+from app.models.media import Media
+from app.models.person import Name, Person
+from app.models.place import Place
+from app.models.relationship import Relationship
+from app.models.source import Citation, Source
+from app.models.tree import Tree, TreeMembership
+from app.models.user import User
+from app.services.audit import record_audit
+from app.services.exceptions import Forbidden, NotFound
+
+EXPORT_VERSION = 1
+_DROP = {"created_at", "updated_at", "deleted_at", "tree_id"}
+# Media columns rebuilt on import (storage is re-keyed, checksum recomputed).
+_MEDIA_DROP = _DROP | {"uploader_id", "storage_key", "byte_size", "checksum_sha256"}
+_DATE_FIELDS = {"date_start", "date_end"}
+
+
+def _row(obj, drop: set[str]) -> dict:
+    out: dict = {}
+    for col in obj.__table__.columns.keys():  # noqa: SIM118
+        if col in drop:
+            continue
+        out[col] = getattr(obj, col)
+    return out
+
+
+async def _entities(session: AsyncSession, model, tree_id: uuid.UUID):
+    stmt = select(model).where(model.tree_id == tree_id, model.deleted_at.is_(None))
+    return list((await session.execute(stmt)).scalars().all())
+
+
+async def export_account(session: AsyncSession, store: ObjectStore, *, user: User) -> bytes:
+    """Build a zip of every tree the user owns: account.json + media blobs."""
+    trees = list(
+        (
+            await session.execute(
+                select(Tree).where(Tree.owner_id == user.id, Tree.deleted_at.is_(None))
+            )
+        ).scalars().all()
+    )
+
+    payload: dict = {
+        "version": EXPORT_VERSION,
+        "user": {"email": user.email, "display_name": user.display_name},
+        "trees": [],
+    }
+    media_blobs: list[tuple[str, bytes]] = []
+
+    for tree in trees:
+        media_rows = await _entities(session, Media, tree.id)
+        media_out = []
+        for m in media_rows:
+            ref = f"media/{m.id}"
+            rec = _row(m, _MEDIA_DROP)
+            rec["_file"] = ref
+            media_out.append(rec)
+            try:
+                media_blobs.append((ref, await store.get_object(key=m.storage_key)))
+            except Exception:  # noqa: BLE001 — a missing blob shouldn't abort the export
+                rec["_file"] = None
+
+        payload["trees"].append({
+            "tree": {
+                "name": tree.name,
+                "description": tree.description,
+                "visibility": tree.visibility,
+                "home_person_id": tree.home_person_id,
+            },
+            "places": [_row(p, _DROP) for p in await _entities(session, Place, tree.id)],
+            "persons": [_row(p, _DROP) for p in await _entities(session, Person, tree.id)],
+            "names": [_row(n, _DROP) for n in await _entities(session, Name, tree.id)],
+            "relationships": [
+                _row(r, _DROP) for r in await _entities(session, Relationship, tree.id)
+            ],
+            "events": [_row(e, _DROP) for e in await _entities(session, Event, tree.id)],
+            "sources": [_row(s, _DROP) for s in await _entities(session, Source, tree.id)],
+            "citations": [_row(c, _DROP) for c in await _entities(session, Citation, tree.id)],
+            "media": media_out,
+        })
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        zf.writestr("account.json", json.dumps(payload, default=str, indent=2))
+        for ref, blob in media_blobs:
+            zf.writestr(ref, blob)
+    return buf.getvalue()
+
+
+def _as_uuid(v) -> uuid.UUID | None:
+    return uuid.UUID(v) if v else None
+
+
+def _as_date(v) -> date | None:
+    return date.fromisoformat(v) if v else None
+
+
+async def import_account(
+    session: AsyncSession, store: ObjectStore, *, user: User, raw_zip: bytes
+) -> dict:
+    """Restore an exported zip into NEW trees owned by the user. Non-destructive:
+    every record gets a fresh id; nothing existing is touched."""
+    try:
+        zf = zipfile.ZipFile(io.BytesIO(raw_zip))
+        payload = json.loads(zf.read("account.json"))
+    except (zipfile.BadZipFile, KeyError, json.JSONDecodeError) as e:
+        raise NotFound("not a valid Provenance export") from e
+
+    counts: dict[str, int] = {"trees": 0, "persons": 0, "events": 0, "media": 0}
+
+    for tdata in payload.get("trees", []):
+        t = tdata.get("tree", {})
+        tree = Tree(
+            owner_id=user.id,
+            name=(t.get("name") or "Imported tree"),
+            description=t.get("description"),
+            visibility=t.get("visibility") or "private",
+        )
+        session.add(tree)
+        await session.flush()
+        session.add(
+            TreeMembership(tree_id=tree.id, user_id=user.id, role=MembershipRole.owner)
+        )
+        counts["trees"] += 1
+
+        # id remaps from the export's ids to the freshly created ones.
+        pmap: dict[str, uuid.UUID] = {}
+        rmap: dict[str, uuid.UUID] = {}
+        smap: dict[str, uuid.UUID] = {}
+        nmap: dict[str, uuid.UUID] = {}
+        emap: dict[str, uuid.UUID] = {}
+        plmap: dict[str, uuid.UUID] = {}
+
+        for pl in tdata.get("places", []):
+            obj = Place(
+                tree_id=tree.id,
+                name=pl.get("name") or "",
+                place_type=pl.get("place_type"),
+                latitude=pl.get("latitude"),
+                longitude=pl.get("longitude"),
+            )
+            session.add(obj)
+            await session.flush()
+            plmap[pl["id"]] = obj.id
+
+        for p in tdata.get("persons", []):
+            obj = Person(
+                tree_id=tree.id,
+                gender=p.get("gender"),
+                is_living=p.get("is_living"),
+                privacy=p.get("privacy") or "inherit",
+                notes=p.get("notes"),
+            )
+            session.add(obj)
+            await session.flush()
+            pmap[p["id"]] = obj.id
+            counts["persons"] += 1
+
+        for n in tdata.get("names", []):
+            pid = pmap.get(n.get("person_id"))
+            if pid is None:
+                continue
+            obj = Name(
+                tree_id=tree.id,
+                person_id=pid,
+                name_type=n.get("name_type") or "birth",
+                given=n.get("given"),
+                surname=n.get("surname"),
+                prefix=n.get("prefix"),
+                suffix=n.get("suffix"),
+                nickname=n.get("nickname"),
+                display_name=n.get("display_name"),
+                is_primary=bool(n.get("is_primary")),
+                sort_order=n.get("sort_order") or 0,
+            )
+            session.add(obj)
+            await session.flush()
+            nmap[n["id"]] = obj.id
+
+        for r in tdata.get("relationships", []):
+            a = pmap.get(r.get("person_from_id"))
+            b = pmap.get(r.get("person_to_id"))
+            if a is None or b is None:
+                continue
+            obj = Relationship(
+                tree_id=tree.id,
+                type=r.get("type"),
+                person_from_id=a,
+                person_to_id=b,
+                qualifier=r.get("qualifier"),
+                notes=r.get("notes"),
+            )
+            session.add(obj)
+            await session.flush()
+            rmap[r["id"]] = obj.id
+
+        for e in tdata.get("events", []):
+            obj = Event(
+                tree_id=tree.id,
+                event_type=e.get("event_type") or "other",
+                person_id=pmap.get(e.get("person_id")),
+                relationship_id=rmap.get(e.get("relationship_id")),
+                place_id=plmap.get(e.get("place_id")),
+                date_value=e.get("date_value"),
+                date_start=_as_date(e.get("date_start")),
+                date_end=_as_date(e.get("date_end")),
+                date_precision=e.get("date_precision"),
+                calendar=e.get("calendar") or "gregorian",
+                detail=e.get("detail"),
+                notes=e.get("notes"),
+            )
+            session.add(obj)
+            await session.flush()
+            emap[e["id"]] = obj.id
+            counts["events"] += 1
+
+        for s in tdata.get("sources", []):
+            obj = Source(
+                tree_id=tree.id,
+                title=s.get("title") or "Untitled source",
+                author=s.get("author"),
+                source_type=s.get("source_type"),
+                repository=s.get("repository"),
+                url=s.get("url"),
+                citation_text=s.get("citation_text"),
+                publication_info=s.get("publication_info"),
+                quality_note=s.get("quality_note"),
+            )
+            session.add(obj)
+            await session.flush()
+            smap[s["id"]] = obj.id
+
+        for c in tdata.get("citations", []):
+            sid = smap.get(c.get("source_id"))
+            if sid is None:
+                continue
+            session.add(
+                Citation(
+                    tree_id=tree.id,
+                    source_id=sid,
+                    person_id=pmap.get(c.get("person_id")),
+                    event_id=emap.get(c.get("event_id")),
+                    name_id=nmap.get(c.get("name_id")),
+                    relationship_id=rmap.get(c.get("relationship_id")),
+                    page=c.get("page"),
+                    detail=c.get("detail"),
+                    confidence=c.get("confidence"),
+                )
+            )
+
+        for m in tdata.get("media", []):
+            ref = m.get("_file")
+            if not ref:
+                continue
+            try:
+                blob = zf.read(ref)
+            except KeyError:
+                continue
+            media_id = uuid.uuid4()
+            filename = m.get("original_filename") or "upload"
+            key = f"{tree.id}/{media_id}/{filename}"
+            await store.ensure_bucket()
+            await store.put_object(
+                key=key,
+                data=blob,
+                content_type=m.get("content_type") or "application/octet-stream",
+            )
+            session.add(
+                Media(
+                    id=media_id,
+                    tree_id=tree.id,
+                    uploader_id=user.id,
+                    storage_key=key,
+                    original_filename=filename,
+                    content_type=m.get("content_type") or "application/octet-stream",
+                    byte_size=len(blob),
+                    checksum_sha256=hashlib.sha256(blob).hexdigest(),
+                    title=m.get("title"),
+                    person_id=pmap.get(m.get("person_id")),
+                    event_id=emap.get(m.get("event_id")),
+                    source_id=smap.get(m.get("source_id")),
+                )
+            )
+            counts["media"] += 1
+
+        # Remap the home person last, once persons exist.
+        home = t.get("home_person_id")
+        if home and home in pmap:
+            tree.home_person_id = pmap[home]
+
+        record_audit(
+            session,
+            action="import",
+            entity_type="Account",
+            entity_id=tree.id,
+            tree_id=tree.id,
+            actor_user_id=user.id,
+            after=counts,
+        )
+
+    await session.commit()
+    return counts
+
+
+async def delete_account(session: AsyncSession, *, user: User, confirm_email: str) -> None:
+    """Soft-delete the account: the user, the trees they own, and all their
+    sessions. Requires the user to retype their email as a guard."""
+    if confirm_email.strip().lower() != user.email.lower():
+        raise Forbidden("email confirmation does not match")
+    now = datetime.now(UTC)
+
+    await session.execute(
+        update(Tree)
+        .where(Tree.owner_id == user.id, Tree.deleted_at.is_(None))
+        .values(deleted_at=now)
+    )
+    await session.execute(
+        update(SessionModel)
+        .where(SessionModel.user_id == user.id, SessionModel.revoked_at.is_(None))
+        .values(revoked_at=now)
+    )
+    user.deleted_at = now
+    record_audit(
+        session,
+        action="delete",
+        entity_type="User",
+        entity_id=user.id,
+        actor_user_id=user.id,
+    )
+    await session.commit()

backend/app/services/audit.py

@@ -3,6 +3,7 @@ the change to a User (or the assistant principal acting for a User). Staged on
 the session; the caller commits as part of its unit of work.
 """
 
+import json
 import uuid
 
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -11,6 +12,14 @@ from app.models.audit import AuditEntry
 from app.models.enums import AuditActorType
 
 
+def _json_safe(d: dict | None) -> dict | None:
+    """Coerce a change dict to JSON-native types (UUIDs, enums, dates -> str) so
+    it lands in the JSON audit column regardless of what the caller passed."""
+    if d is None:
+        return None
+    return json.loads(json.dumps(d, default=str))
+
+
 def record_audit(
     session: AsyncSession,
     *,
@@ -30,8 +39,8 @@ def record_audit(
         tree_id=tree_id,
         actor_user_id=actor_user_id,
         actor_type=actor_type,
-        before=before,
+        before=_json_safe(before),
-        after=after,
+        after=_json_safe(after),
     )
     session.add(entry)
     return entry

backend/app/services/auth_service.py

@@ -9,7 +9,7 @@ from sqlalchemy import select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.core.config import get_settings
-from app.core.security import generate_token, hash_password, hash_token
+from app.core.security import generate_token, hash_password, hash_token, verify_password
 from app.integrations.auth.local import LocalAuthProvider
 from app.integrations.mailer.base import Mailer
 from app.models.auth import Session as SessionModel
@@ -17,7 +17,7 @@ from app.models.auth import UserToken
 from app.models.enums import TokenPurpose
 from app.models.user import User
 from app.services.audit import record_audit
-from app.services.exceptions import Conflict, NotFound
+from app.services.exceptions import Conflict, Forbidden, NotFound
 
 _local_provider = LocalAuthProvider()
 
@@ -178,6 +178,26 @@ async def request_password_reset(session: AsyncSession, mailer: Mailer, *, email
     await mailer.send_password_reset(to=email, link=_link("/auth/reset-password", raw))
 
 
+async def change_password(
+    session: AsyncSession, *, user: User, current_password: str, new_password: str
+) -> None:
+    """Change a logged-in user's password after re-verifying the current one.
+    Revokes other sessions so a changed password takes effect everywhere."""
+    if not user.hashed_password or not verify_password(
+        user.hashed_password, current_password
+    ):
+        raise Forbidden("current password is incorrect")
+    user.hashed_password = hash_password(new_password)
+    record_audit(
+        session,
+        action="change_password",
+        entity_type="User",
+        entity_id=user.id,
+        actor_user_id=user.id,
+    )
+    await session.commit()
+
+
 async def reset_password(session: AsyncSession, *, raw_token: str, new_password: str) -> None:
     token = await _consume_token(session, raw_token, TokenPurpose.password_reset)
     await session.execute(

backend/app/services/citation_service.py

@@ -113,6 +113,38 @@ async def list_citations(
     return list((await session.execute(stmt)).scalars().all())
 
 
+async def update_citation(
+    session: AsyncSession, *, actor: User, tree: Tree, citation_id: uuid.UUID, changes: dict
+) -> Citation:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    citation = (
+        await session.execute(
+            select(Citation).where(
+                Citation.id == citation_id,
+                Citation.tree_id == tree.id,
+                Citation.deleted_at.is_(None),
+            )
+        )
+    ).scalar_one_or_none()
+    if citation is None:
+        raise NotFound("citation not found")
+    for key in {"page", "detail", "confidence"} & changes.keys():
+        setattr(citation, key, changes[key])
+    record_audit(
+        session,
+        action="update",
+        entity_type="Citation",
+        entity_id=citation.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after=changes,
+    )
+    await session.commit()
+    await session.refresh(citation)
+    return citation
+
+
 async def delete_citation(
     session: AsyncSession, *, actor: User, tree: Tree, citation_id: uuid.UUID
 ) -> None:

backend/app/services/cleanup_service.py

@@ -0,0 +1,289 @@
+"""Bulk tree cleanup — preview/apply pairs for common import messes.
+
+Per the project's #1 rule (the assistant proposes, humans approve), each fix has
+a *preview* that returns the proposed changes and an *apply* that commits only
+the ids/edits the user confirmed. Nothing here mutates without an explicit apply
+call carrying the user's selections.
+"""
+
+import re
+import uuid
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.event import Event
+from app.models.person import Name, Person
+from app.models.tree import Tree
+from app.models.user import User
+from app.services import gedcom, privacy
+from app.services.audit import record_audit
+from app.services.exceptions import Forbidden, NotFound
+from app.services.name_gender_data import guess_sex
+
+
+async def _require_editor(session: AsyncSession, *, actor: User, tree: Tree) -> None:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+
+
+async def _persons(session: AsyncSession, tree_id: uuid.UUID) -> list[Person]:
+    return list(
+        (
+            await session.execute(
+                select(Person).where(Person.tree_id == tree_id, Person.deleted_at.is_(None))
+            )
+        ).scalars().all()
+    )
+
+
+async def _primary_name_by_person(
+    session: AsyncSession, tree_id: uuid.UUID
+) -> dict[uuid.UUID, Name]:
+    names = (
+        await session.execute(
+            select(Name)
+            .where(Name.tree_id == tree_id, Name.deleted_at.is_(None))
+            .order_by(Name.is_primary.desc(), Name.sort_order)
+        )
+    ).scalars().all()
+    out: dict[uuid.UUID, Name] = {}
+    for n in names:
+        out.setdefault(n.person_id, n)
+    return out
+
+
+async def _birth_year_by_person(session: AsyncSession, tree_id: uuid.UUID) -> dict[uuid.UUID, int]:
+    evs = (
+        await session.execute(
+            select(Event).where(
+                Event.tree_id == tree_id,
+                Event.deleted_at.is_(None),
+                Event.event_type == "birth",
+            )
+        )
+    ).scalars().all()
+    out: dict[uuid.UUID, int] = {}
+    for e in evs:
+        if not e.person_id or e.person_id in out:
+            continue
+        y = e.date_start.year if e.date_start else None
+        if y is None:
+            ys = gedcom._year(e.date_value)
+            y = int(ys) if ys else None
+        if y is not None:
+            out[e.person_id] = y
+    return out
+
+
+def _display(n: Name | None) -> str:
+    if n is None:
+        return "Unnamed"
+    return " ".join(x for x in (n.given, n.surname) if x) or (n.display_name or "Unnamed")
+
+
+# ---- 1. Mark deceased by birth year -------------------------------------------------
+
+async def preview_deceased(
+    session: AsyncSession, *, actor: User, tree: Tree, year: int
+) -> list[dict]:
+    await _require_editor(session, actor=actor, tree=tree)
+    names = await _primary_name_by_person(session, tree.id)
+    years = await _birth_year_by_person(session, tree.id)
+    out: list[dict] = []
+    for p in await _persons(session, tree.id):
+        if p.is_living is False:  # already deceased
+            continue
+        by = years.get(p.id)
+        if by is not None and by <= year:
+            out.append(
+                {"person_id": str(p.id), "name": _display(names.get(p.id)), "birth_year": by}
+            )
+    out.sort(key=lambda r: r["birth_year"])
+    return out
+
+
+async def apply_deceased(
+    session: AsyncSession, *, actor: User, tree: Tree, person_ids: list[uuid.UUID]
+) -> int:
+    await _require_editor(session, actor=actor, tree=tree)
+    persons = (
+        await session.execute(
+            select(Person).where(
+                Person.tree_id == tree.id,
+                Person.deleted_at.is_(None),
+                Person.id.in_(person_ids),
+            )
+        )
+    ).scalars().all()
+    for p in persons:
+        p.is_living = False
+    record_audit(
+        session,
+        action="cleanup_deceased",
+        entity_type="Tree",
+        entity_id=tree.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after={"count": len(persons)},
+    )
+    await session.commit()
+    return len(persons)
+
+
+# ---- 2. Re-derive gender from a source GEDCOM (matches by name) ----------------------
+
+async def preview_gender(
+    session: AsyncSession, *, actor: User, tree: Tree, gedcom_text: str
+) -> list[dict]:
+    await _require_editor(session, actor=actor, tree=tree)
+    name2sex: dict[str, str] = {}
+    for rec in gedcom.parse_records(gedcom_text):
+        if rec.tag != "INDI":
+            continue
+        summ = gedcom._person_summary(rec)
+        sex = gedcom._sex(rec.text("SEX"))
+        if sex and summ["norm"]:
+            name2sex.setdefault(summ["norm"], sex)
+
+    names = await _primary_name_by_person(session, tree.id)
+    out: list[dict] = []
+    for p in await _persons(session, tree.id):
+        if p.gender:  # only fill in what's missing
+            continue
+        nm = names.get(p.id)
+        if nm is None:
+            continue
+        proposed = name2sex.get(gedcom._norm(nm.given, nm.surname))
+        if proposed:
+            out.append({"person_id": str(p.id), "name": _display(nm), "proposed_gender": proposed})
+    out.sort(key=lambda r: r["name"])
+    return out
+
+
+async def guess_gender_by_name(
+    session: AsyncSession, *, actor: User, tree: Tree
+) -> list[dict]:
+    """Best-guess sex from the first given name for people who don't have it set,
+    using the bundled name dictionary. Ambiguous/unknown names are skipped."""
+    await _require_editor(session, actor=actor, tree=tree)
+    names = await _primary_name_by_person(session, tree.id)
+    out: list[dict] = []
+    for p in await _persons(session, tree.id):
+        if p.gender:
+            continue
+        nm = names.get(p.id)
+        if nm is None:
+            continue
+        proposed = guess_sex(nm.given)
+        if proposed:
+            out.append({"person_id": str(p.id), "name": _display(nm), "proposed_gender": proposed})
+    out.sort(key=lambda r: r["name"])
+    return out
+
+
+async def apply_gender(
+    session: AsyncSession, *, actor: User, tree: Tree, updates: list[dict]
+) -> int:
+    """updates: [{person_id, gender}]."""
+    await _require_editor(session, actor=actor, tree=tree)
+    wanted = {uuid.UUID(str(u["person_id"])): u["gender"] for u in updates if u.get("gender")}
+    persons = (
+        await session.execute(
+            select(Person).where(
+                Person.tree_id == tree.id,
+                Person.deleted_at.is_(None),
+                Person.id.in_(wanted.keys()),
+            )
+        )
+    ).scalars().all()
+    for p in persons:
+        p.gender = wanted[p.id]
+    record_audit(
+        session,
+        action="cleanup_gender",
+        entity_type="Tree",
+        entity_id=tree.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after={"count": len(persons)},
+    )
+    await session.commit()
+    return len(persons)
+
+
+# ---- 3. Flag malformed names for review --------------------------------------------
+
+_YEAR_RE = re.compile(r"\b\d{3,4}\b")
+
+
+def _name_issue(n: Name) -> str | None:
+    given = (n.given or "").strip()
+    surname = (n.surname or "").strip()
+    if _YEAR_RE.search(surname) or re.search(r"\d", surname):
+        return "date_in_surname"
+    if re.search(r"\d", given):
+        return "date_in_given"
+    # A given name with many tokens often means a maiden+married name was packed
+    # in (e.g. "Mary Smith Jones") — surface it for a human to split.
+    if surname == "" and len(given.split()) >= 2:
+        return "no_surname"
+    if len(given.split()) >= 3:
+        return "packed_given"
+    return None
+
+
+async def preview_names(session: AsyncSession, *, actor: User, tree: Tree) -> list[dict]:
+    await _require_editor(session, actor=actor, tree=tree)
+    names = (
+        await session.execute(
+            select(Name).where(Name.tree_id == tree.id, Name.deleted_at.is_(None))
+        )
+    ).scalars().all()
+    out: list[dict] = []
+    for n in names:
+        issue = _name_issue(n)
+        if issue:
+            out.append({
+                "name_id": str(n.id),
+                "person_id": str(n.person_id),
+                "given": n.given,
+                "surname": n.surname,
+                "issue": issue,
+            })
+    return out
+
+
+async def apply_names(
+    session: AsyncSession, *, actor: User, tree: Tree, edits: list[dict]
+) -> int:
+    """edits: [{name_id, given, surname}] — the user's corrected values."""
+    await _require_editor(session, actor=actor, tree=tree)
+    by_id = {uuid.UUID(str(e["name_id"])): e for e in edits}
+    rows = (
+        await session.execute(
+            select(Name).where(
+                Name.tree_id == tree.id,
+                Name.deleted_at.is_(None),
+                Name.id.in_(by_id.keys()),
+            )
+        )
+    ).scalars().all()
+    if len(rows) != len(by_id):
+        raise NotFound("one or more names not found in this tree")
+    for n in rows:
+        e = by_id[n.id]
+        n.given = (e.get("given") or "").strip() or None
+        n.surname = (e.get("surname") or "").strip() or None
+        n.display_name = None  # rebuild from parts
+    record_audit(
+        session,
+        action="cleanup_names",
+        entity_type="Tree",
+        entity_id=tree.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after={"count": len(rows)},
+    )
+    await session.commit()
+    return len(rows)

backend/app/services/gedcom.py

@@ -4,14 +4,20 @@ A pragmatic parser + mapper for the common subset of GEDCOM (5.5.1 / 7 share
 the line grammar): INDI, FAM, SOUR. Import maps records into a tree and returns
 a mapping report (counts + unmapped tags); export serializes the tree back to
 GEDCOM. Runs inline for now — large files should move to the worker later.
+
+Import is duplicate-aware: ``preview_gedcom`` reports incoming people that look
+like existing ones, and ``import_gedcom`` applies a per-record resolution
+(new / skip / merge / overwrite). Names carry their GEDCOM type (a married name
+imports as a typed alternate, not a second primary).
 """
 
 import re
 import uuid
 from collections import defaultdict
-from datetime import date
+from datetime import UTC, date, datetime
+from difflib import SequenceMatcher
 
-from sqlalchemy import select
+from sqlalchemy import or_, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.enums import ParentChildQualifier, RelationshipType
@@ -32,12 +38,31 @@ INDI_EVENTS = {
     "BURI": "burial", "CREM": "cremation", "RESI": "residence", "CENS": "census",
     "IMMI": "immigration", "EMIG": "emigration", "OCCU": "occupation",
     "EDUC": "education", "GRAD": "graduation", "RETI": "retirement",
-    "NATU": "naturalization", "BAPL": "baptism",
+    "NATU": "naturalization", "BAPL": "baptism", "RELI": "religion",
+}
+# INDI attribute tags whose line VALUE is the fact (no date), stored in detail.
+VALUE_EVENTS = {"RELI", "OCCU", "EDUC"}
+# INDI sub-tags consumed elsewhere or intentionally ignored (not "unmapped").
+INDI_SKIP_TAGS = {
+    "NAME", "SEX", "SOUR", "FAMC", "FAMS", "CHAN", "OBJE", "_UID", "_MARNM", "NOTE",
 }
 # FAM-level events.
 FAM_EVENTS = {"MARR": "marriage", "DIV": "divorce", "ENGA": "engagement"}
 EVENT_TO_GED = {v: k for k, v in {**INDI_EVENTS, **FAM_EVENTS}.items()}
 
+# GEDCOM NAME TYPE (or _MARNM-derived) -> our Name.name_type vocabulary.
+NAME_TYPE_MAP = {
+    "birth": "birth", "maiden": "birth", "married": "married",
+    "aka": "alias", "also known as": "alias", "nickname": "nickname",
+    "religious": "religious", "immigrant": "immigration",
+    "immigration": "immigration", "professional": "alias", "other": "alias",
+}
+# Our type -> GEDCOM TYPE on export (birth is the default; emit nothing).
+EXPORT_TYPE_MAP = {
+    "married": "married", "alias": "aka", "nickname": "nickname",
+    "religious": "religious", "immigration": "immigrant",
+}
+
 
 class GedcomNode:
     __slots__ = ("level", "tag", "value", "xref", "children")
@@ -108,6 +133,50 @@ def _parse_name(value: str) -> tuple[str | None, str | None]:
     return value.strip() or None, None
 
 
+def _parse_marnm(value: str, base_given: str | None) -> tuple[str | None, str | None]:
+    """A _MARNM value is sometimes a full name ("Jane /Smith/") and sometimes
+    just the married surname ("Smith"). Keep the given name from the base name
+    in the latter case."""
+    v = (value or "").strip()
+    if "/" in v:
+        g, s = _parse_name(v)
+        return (g or base_given), s
+    return base_given, (v or None)
+
+
+def _extract_names(rec: GedcomNode) -> list[dict]:
+    """All names for an INDI, typed. Multiple NAME records (each with an optional
+    TYPE) plus any _MARNM (married name) subtags become separate Name rows. The
+    first birth/maiden name is primary."""
+    out: list[dict] = []
+    for nm in rec.all("NAME"):
+        g, s = _parse_name(nm.value)
+        t = (nm.text("TYPE") or "").strip().lower()
+        ntype = NAME_TYPE_MAP.get(t, t or "birth")
+        out.append({"type": ntype, "given": g, "surname": s, "display": nm.value or None,
+                    "nickname": nm.text("NICK")})
+        for mar in nm.all("_MARNM"):
+            mg, ms = _parse_marnm(mar.value, g)
+            out.append({"type": "married", "given": mg, "surname": ms,
+                        "display": mar.value or None, "nickname": None})
+    for mar in rec.all("_MARNM"):
+        base_g = out[0]["given"] if out else None
+        mg, ms = _parse_marnm(mar.value, base_g)
+        out.append({"type": "married", "given": mg, "surname": ms,
+                    "display": mar.value or None, "nickname": None})
+    if not out:
+        return out
+    primary_idx = next((i for i, n in enumerate(out) if n["type"] == "birth"), 0)
+    for i, n in enumerate(out):
+        n["is_primary"] = i == primary_idx
+        n["sort"] = i
+    return out
+
+
+def _norm(given: str | None, surname: str | None) -> str:
+    return re.sub(r"\s+", " ", f"{given or ''} {surname or ''}".strip().lower())
+
+
 def _year(date_value: str | None) -> str | None:
     if not date_value:
         return None
@@ -132,18 +201,215 @@ def _sex(value: str | None) -> str | None:
     return {"M": "male", "F": "female"}.get(v, value.strip().lower() or None)
 
 
+def _notes_text(rec: GedcomNode) -> str | None:
+    """Join an INDI's NOTE lines (which pack confidence / findagrave / fs_pid /
+    free text) into the person's notes field."""
+    vals = [n.value.strip() for n in rec.all("NOTE") if n.value and n.value.strip()]
+    return "\n".join(vals) or None
+
+
+def _person_summary(rec: GedcomNode) -> dict:
+    """Display name + birth year for an incoming INDI, for duplicate matching."""
+    names = _extract_names(rec)
+    primary = next((n for n in names if n.get("is_primary")), names[0] if names else None)
+    g = primary["given"] if primary else None
+    s = primary["surname"] if primary else None
+    disp = " ".join(x for x in (g, s) if x)
+    if not disp and primary:
+        disp = primary.get("display") or ""
+    birth = rec.first("BIRT")
+    year = _year(birth.text("DATE")) if birth else None
+    return {"names": names, "norm": _norm(g, s), "name": disp or "(no name)", "year": year}
+
+
+async def _build_existing_index(session: AsyncSession, tree: Tree) -> list[dict]:
+    """Existing (non-deleted) people with a display name + birth year, for
+    matching incoming records against."""
+    persons = list(
+        (
+            await session.execute(
+                select(Person).where(Person.tree_id == tree.id, Person.deleted_at.is_(None))
+            )
+        ).scalars().all()
+    )
+    names = list(
+        (
+            await session.execute(
+                select(Name).where(Name.tree_id == tree.id, Name.deleted_at.is_(None))
+            )
+        ).scalars().all()
+    )
+    name_by_person: dict[uuid.UUID, Name] = {}
+    for n in sorted(names, key=lambda n: (not n.is_primary, n.sort_order)):
+        name_by_person.setdefault(n.person_id, n)
+    births = list(
+        (
+            await session.execute(
+                select(Event).where(
+                    Event.tree_id == tree.id,
+                    Event.deleted_at.is_(None),
+                    Event.event_type == "birth",
+                )
+            )
+        ).scalars().all()
+    )
+    year_by_person: dict[uuid.UUID, str] = {}
+    for e in births:
+        if e.person_id and e.person_id not in year_by_person:
+            y = str(e.date_start.year) if e.date_start else _year(e.date_value)
+            if y:
+                year_by_person[e.person_id] = y
+
+    index: list[dict] = []
+    for p in persons:
+        nm = name_by_person.get(p.id)
+        g = nm.given if nm else None
+        s = nm.surname if nm else None
+        disp = " ".join(x for x in (g, s) if x) or (nm.display_name if nm else None)
+        index.append({
+            "id": p.id,
+            "norm": _norm(g, s),
+            "name": disp or "(no name)",
+            "year": year_by_person.get(p.id),
+        })
+    return index
+
+
+def _best_match(norm: str, year: str | None, index: list[dict]) -> tuple[dict | None, str | None]:
+    """Closest existing person by name similarity, rejecting clear birth-year
+    conflicts. Returns (entry, "high"|"medium") or (None, None)."""
+    if not norm:
+        return None, None
+    best: dict | None = None
+    best_r = 0.0
+    for e in index:
+        if not e["norm"]:
+            continue
+        r = SequenceMatcher(None, norm, e["norm"]).ratio()
+        if r < 0.88:
+            continue
+        if year and e["year"] and abs(int(year) - int(e["year"])) > 1:
+            continue  # same-ish name but different birth year — not a duplicate
+        if r > best_r:
+            best_r = r
+            best = e
+    if best is None:
+        return None, None
+    year_match = bool(year and best["year"] and abs(int(year) - int(best["year"])) <= 1)
+    both_unknown = not year and not best["year"]
+    score = "high" if best_r >= 0.93 and (year_match or both_unknown) else "medium"
+    return best, score
+
+
+def _relkey(rtype: RelationshipType, a: uuid.UUID, b: uuid.UUID) -> tuple:
+    if rtype == RelationshipType.parent_child:
+        return ("pc", str(a), str(b))
+    return (rtype.value, *sorted([str(a), str(b)]))
+
+
+def _count_incoming(roots: list[GedcomNode]) -> tuple[dict, list[str]]:
+    counts: dict[str, int] = defaultdict(int)
+    unmapped: set[str] = set()
+    for rec in roots:
+        if rec.tag == "INDI" and rec.xref:
+            counts["persons"] += 1
+            counts["names"] += len(_extract_names(rec))
+            for child in rec.children:
+                if child.tag in INDI_EVENTS:
+                    counts["events"] += 1
+                elif child.tag not in INDI_SKIP_TAGS:
+                    unmapped.add(child.tag)
+        elif rec.tag == "FAM":
+            counts["families"] += 1
+            for child in rec.children:
+                if child.tag in FAM_EVENTS:
+                    counts["events"] += 1
+        elif rec.tag == "SOUR" and rec.xref:
+            counts["sources"] += 1
+    return dict(counts), sorted(unmapped)
+
+
+async def preview_gedcom(session: AsyncSession, *, actor: User, tree: Tree, text: str) -> dict:
+    """Dry run: what would import, and which incoming people look like existing
+    ones. No writes."""
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    roots = parse_records(text)
+    counts, unmapped = _count_incoming(roots)
+    index = await _build_existing_index(session, tree)
+
+    duplicates: list[dict] = []
+    for rec in roots:
+        if rec.tag != "INDI" or not rec.xref:
+            continue
+        summ = _person_summary(rec)
+        entry, score = _best_match(summ["norm"], summ["year"], index)
+        if entry is None:
+            continue
+        duplicates.append({
+            "xref": rec.xref,
+            "incoming_name": summ["name"],
+            "incoming_birth_year": summ["year"],
+            "existing_person_id": entry["id"],
+            "existing_name": entry["name"],
+            "existing_birth_year": entry["year"],
+            "score": score,
+        })
+    return {"counts": counts, "potential_duplicates": duplicates, "unmapped_tags": unmapped}
+
+
 async def import_gedcom(
-    session: AsyncSession, *, actor: User, tree: Tree, text: str
+    session: AsyncSession,
+    *,
+    actor: User,
+    tree: Tree,
+    text: str,
+    default_action: str = "new",
+    resolutions: dict | None = None,
 ) -> dict:
+    """Import records. ``default_action`` (new|skip|merge|overwrite) applies to
+    incoming people that match an existing one; ``resolutions`` overrides it per
+    GEDCOM xref ({xref: {action, target_id}}). 'skip' links families to the
+    existing person but copies nothing; 'merge' also copies the incoming names
+    (as alternates), events and citations onto them; 'overwrite' deletes the
+    existing person and imports the incoming one fresh."""
     if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
         raise Forbidden("not an editor of this tree")
 
+    resolutions = resolutions or {}
     roots = parse_records(text)
-    counts = defaultdict(int)
+    counts: dict[str, int] = defaultdict(int)
     unmapped: set[str] = set()
     place_cache: dict[str, uuid.UUID] = {}
     source_map: dict[str, uuid.UUID] = {}
     person_map: dict[str, uuid.UUID] = {}
+    now = datetime.now(UTC)
+
+    index = await _build_existing_index(session, tree)
+
+    # Pre-load existing relationship keys so a merge doesn't create dup edges.
+    existing_rels = list(
+        (
+            await session.execute(
+                select(Relationship).where(
+                    Relationship.tree_id == tree.id, Relationship.deleted_at.is_(None)
+                )
+            )
+        ).scalars().all()
+    )
+    rel_keys = {_relkey(r.type, r.person_from_id, r.person_to_id) for r in existing_rels}
+
+    def add_relationship(
+        rtype: RelationshipType, a: uuid.UUID, b: uuid.UUID, **kw
+    ) -> Relationship | None:
+        key = _relkey(rtype, a, b)
+        if key in rel_keys:
+            return None
+        rel = Relationship(tree_id=tree.id, type=rtype, person_from_id=a, person_to_id=b, **kw)
+        session.add(rel)
+        rel_keys.add(key)
+        counts["relationships"] += 1
+        return rel
 
     async def place_id(name: str | None) -> uuid.UUID | None:
         if not name:
@@ -177,59 +443,139 @@ async def import_gedcom(
             sid = source_map.get(s.value.strip())
             if sid is None:
                 continue
-            session.add(
+            session.add(Citation(tree_id=tree.id, source_id=sid, page=s.text("PAGE"), **target))
-                Citation(tree_id=tree.id, source_id=sid, page=s.text("PAGE"), **target)
-            )
             counts["citations"] += 1
 
-    # Individuals.
+    def add_names(person_id: uuid.UUID, names: list[dict], *, set_primary: bool) -> None:
-    for rec in roots:
+        for nd in names:
-        if rec.tag != "INDI" or not rec.xref:
-            continue
-        person = Person(tree_id=tree.id, gender=_sex(rec.text("SEX")))
-        session.add(person)
-        await session.flush()
-        person_map[rec.xref] = person.id
-        counts["persons"] += 1
-
-        for i, nm in enumerate(rec.all("NAME")):
-            given, surname = _parse_name(nm.value)
             session.add(
                 Name(
                     tree_id=tree.id,
-                    person_id=person.id,
+                    person_id=person_id,
-                    name_type="birth",
+                    name_type=nd["type"],
-                    given=given,
+                    given=nd["given"],
-                    surname=surname,
+                    surname=nd["surname"],
-                    display_name=nm.value or None,
+                    nickname=nd.get("nickname"),
-                    is_primary=(i == 0),
+                    display_name=nd.get("display"),
-                    sort_order=i,
+                    is_primary=set_primary and nd.get("is_primary", False),
+                    sort_order=nd.get("sort", 0),
                 )
             )
             counts["names"] += 1
 
-        await add_citations(rec, person_id=person.id)
+    async def add_events(rec: GedcomNode, person_id: uuid.UUID) -> None:
-
         for child in rec.children:
             if child.tag in INDI_EVENTS:
                 dv = child.text("DATE")
+                # Attribute-style facts (RELI, OCCU, EDUC) carry their value on
+                # the line itself; store it in detail.
+                detail = child.value.strip() if child.tag in VALUE_EVENTS else None
                 ev = Event(
                     tree_id=tree.id,
-                    person_id=person.id,
+                    person_id=person_id,
                     event_type=INDI_EVENTS[child.tag],
                     date_value=dv,
                     date_start=_date_start(dv),
                     place_id=await place_id(child.text("PLAC")),
+                    detail=detail or None,
+                    notes=child.text("NOTE"),
                 )
                 session.add(ev)
                 await session.flush()
                 counts["events"] += 1
                 await add_citations(child, event_id=ev.id)
-            elif child.tag in ("NAME", "SEX", "SOUR", "FAMC", "FAMS", "CHAN", "OBJE", "_UID"):
+            elif child.tag in INDI_SKIP_TAGS:
                 continue
             else:
                 unmapped.add(child.tag)
 
+    async def soft_delete_existing(person_id: uuid.UUID) -> None:
+        p = (
+            await session.execute(
+                select(Person).where(Person.id == person_id, Person.deleted_at.is_(None))
+            )
+        ).scalar_one_or_none()
+        if p is None:
+            return
+        p.deleted_at = now
+        rels = (
+            await session.execute(
+                select(Relationship).where(
+                    Relationship.tree_id == tree.id,
+                    Relationship.deleted_at.is_(None),
+                    or_(
+                        Relationship.person_from_id == person_id,
+                        Relationship.person_to_id == person_id,
+                    ),
+                )
+            )
+        ).scalars().all()
+        for r in rels:
+            r.deleted_at = now
+        await session.execute(
+            update(User).where(User.self_person_id == person_id).values(self_person_id=None)
+        )
+
+    # Precompute the best match per incoming xref (for default-policy resolution).
+    matches: dict[str, dict] = {}
+    for rec in roots:
+        if rec.tag == "INDI" and rec.xref:
+            summ = _person_summary(rec)
+            entry, _score = _best_match(summ["norm"], summ["year"], index)
+            if entry is not None:
+                matches[rec.xref] = entry
+
+    def resolve(xref: str) -> tuple[str, uuid.UUID | None]:
+        ov = resolutions.get(xref)
+        if ov:
+            action = ov.get("action", "new")
+            tid = ov.get("target_id")
+            target = uuid.UUID(tid) if tid else (matches[xref]["id"] if xref in matches else None)
+            if action in ("skip", "merge", "overwrite") and target is None:
+                return "new", None
+            return action, target
+        if default_action != "new" and xref in matches:
+            return default_action, matches[xref]["id"]
+        return "new", None
+
+    # Individuals.
+    for rec in roots:
+        if rec.tag != "INDI" or not rec.xref:
+            continue
+        names = _extract_names(rec)
+        action, target = resolve(rec.xref)
+
+        if action == "skip" and target is not None:
+            person_map[rec.xref] = target
+            counts["skipped"] += 1
+            continue
+        if action == "merge" and target is not None:
+            person_map[rec.xref] = target
+            add_names(target, names, set_primary=False)
+            await add_events(rec, target)
+            await add_citations(rec, person_id=target)
+            note = _notes_text(rec)
+            if note:
+                existing = (
+                    await session.execute(select(Person).where(Person.id == target))
+                ).scalar_one_or_none()
+                if existing is not None:
+                    existing.notes = "\n".join(filter(None, [existing.notes, note]))
+            counts["merged"] += 1
+            continue
+        if action == "overwrite" and target is not None:
+            await soft_delete_existing(target)
+            counts["overwritten"] += 1
+
+        person = Person(tree_id=tree.id, gender=_sex(rec.text("SEX")), notes=_notes_text(rec))
+        session.add(person)
+        await session.flush()
+        person_map[rec.xref] = person.id
+        counts["persons"] += 1
+        add_names(person.id, names, set_primary=True)
+        await add_citations(rec, person_id=person.id)
+        await add_events(rec, person.id)
+
     # Families -> partnerships, parent-child edges, marriage events.
     for rec in roots:
         if rec.tag != "FAM":
@@ -238,17 +584,22 @@ async def import_gedcom(
         husb = person_map.get((rec.text("HUSB") or "").strip())
         wife = person_map.get((rec.text("WIFE") or "").strip())
         partnership_id: uuid.UUID | None = None
-        if husb and wife:
+        if husb and wife and husb != wife:
-            rel = Relationship(
+            rel = add_relationship(RelationshipType.partnership, husb, wife)
-                tree_id=tree.id,
+            if rel is not None:
-                type=RelationshipType.partnership,
+                await session.flush()
-                person_from_id=husb,
+                partnership_id = rel.id
-                person_to_id=wife,
+        if partnership_id is None and husb and wife:
+            # Edge already existed — find it so marriage events can attach.
+            existing = next(
+                (
+                    r for r in existing_rels
+                    if r.type == RelationshipType.partnership
+                    and {r.person_from_id, r.person_to_id} == {husb, wife}
+                ),
+                None,
             )
-            session.add(rel)
+            partnership_id = existing.id if existing else None
-            await session.flush()
-            partnership_id = rel.id
-            counts["relationships"] += 1
 
         for fe in rec.children:
             if fe.tag in FAM_EVENTS and partnership_id is not None:
@@ -271,16 +622,12 @@ async def import_gedcom(
                 continue
             for parent in (husb, wife):
                 if parent and parent != cp:
-                    session.add(
+                    add_relationship(
-                        Relationship(
+                        RelationshipType.parent_child,
-                            tree_id=tree.id,
+                        parent,
-                            type=RelationshipType.parent_child,
+                        cp,
-                            person_from_id=parent,
+                        qualifier=ParentChildQualifier.biological,
-                            person_to_id=cp,
-                            qualifier=ParentChildQualifier.biological,
-                        )
                     )
-                    counts["relationships"] += 1
 
     record_audit(
         session,
@@ -397,6 +744,9 @@ async def export_gedcom(session: AsyncSession, *, viewer_id: uuid.UUID, tree: Tr
         for n in names_by_person.get(p.id, []):
             display = n.display_name or f"{n.given or ''} /{n.surname or ''}/".strip()
             out.append(f"1 NAME {display}")
+            ged_type = EXPORT_TYPE_MAP.get(n.name_type)
+            if ged_type:
+                out.append(f"2 TYPE {ged_type}")
         sex = {"male": "M", "female": "F"}.get(p.gender or "")
         if sex:
             out.append(f"1 SEX {sex}")

backend/app/services/media_service.py

@@ -97,6 +97,36 @@ async def get_media(
     return media
 
 
+async def update_media(
+    session: AsyncSession, *, actor: User, tree: Tree, media_id: uuid.UUID, changes: dict
+) -> Media:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    media = (
+        await session.execute(
+            select(Media).where(
+                Media.id == media_id, Media.tree_id == tree.id, Media.deleted_at.is_(None)
+            )
+        )
+    ).scalar_one_or_none()
+    if media is None:
+        raise NotFound("media not found")
+    for key in {"title", "person_id", "event_id", "source_id"} & changes.keys():
+        setattr(media, key, changes[key])
+    record_audit(
+        session,
+        action="update",
+        entity_type="Media",
+        entity_id=media.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after=changes,
+    )
+    await session.commit()
+    await session.refresh(media)
+    return media
+
+
 async def delete_media(
     session: AsyncSession, *, actor: User, tree: Tree, media_id: uuid.UUID
 ) -> None:

backend/app/services/name_gender_data.py

@@ -0,0 +1,69 @@
+"""A curated given-name -> sex lookup for best-guessing a person's sex from
+their first name. Weighted toward English + German names (this codebase's first
+real tree is a German-American family). Deterministic and offline — no model
+needed; the Cleanup tool previews every guess before anything is applied.
+
+Genuinely ambiguous names (Marion, Frances/Francis, Jordan, Jamie, Robin, Leslie,
+Dana, …) are intentionally left out of BOTH sets so they aren't guessed — better
+a human decides those than a coin flip.
+"""
+
+MALE_NAMES: set[str] = {
+    # English / common US
+    "james", "john", "robert", "michael", "william", "david", "richard", "joseph",
+    "thomas", "charles", "christopher", "daniel", "matthew", "anthony", "donald",
+    "mark", "paul", "steven", "andrew", "kenneth", "george", "joshua", "kevin",
+    "brian", "edward", "ronald", "timothy", "jason", "jeffrey", "gary", "ryan",
+    "nicholas", "eric", "stephen", "jacob", "larry", "frank", "jonathan", "scott",
+    "raymond", "gregory", "samuel", "benjamin", "patrick", "jack", "dennis", "jerry",
+    "alexander", "tyler", "henry", "douglas", "peter", "adam", "harold", "albert",
+    "arthur", "carl", "ralph", "roy", "eugene", "louis", "philip", "bobby", "walter",
+    "willie", "wayne", "fred", "howard", "ernest", "earl", "clarence", "leon",
+    "leonard", "lewis", "floyd", "leroy", "elmer", "homer", "orrin", "josias",
+    "emerson", "dale", "bernard", "vernon", "virgil", "wilbur", "russell",
+    "harvey", "herbert", "melvin", "lloyd", "marvin", "norman", "stanley",
+    # German
+    "hans", "karl", "wilhelm", "friedrich", "heinrich", "otto", "hermann", "gustav",
+    "ludwig", "ernst", "fritz", "johann", "conrad", "konrad", "reinhold", "rudolf",
+    "rudolph", "gerhard", "helmut", "horst", "klaus", "kurt", "dieter", "günther",
+    "gunther", "manfred", "siegfried", "hilgard", "christian", "august", "wolfgang",
+    "jürgen", "jurgen", "matthias", "lothar", "bruno", "gottlieb", "reinhard",
+}
+
+FEMALE_NAMES: set[str] = {
+    # English / common US
+    "mary", "patricia", "jennifer", "linda", "elizabeth", "barbara", "susan",
+    "jessica", "sarah", "karen", "nancy", "lisa", "betty", "margaret", "sandra",
+    "ashley", "kimberly", "emily", "donna", "michelle", "carol", "amanda", "dorothy",
+    "melissa", "deborah", "stephanie", "rebecca", "sharon", "laura", "cynthia",
+    "kathleen", "amy", "angela", "shirley", "anna", "ruth", "brenda", "pamela",
+    "nicole", "katherine", "virginia", "catherine", "helen", "debra", "rachel",
+    "carolyn", "janet", "maria", "heather", "diane", "julie", "joyce", "victoria",
+    "kelly", "christina", "joan", "evelyn", "judith", "megan", "alice", "frances",
+    "marie", "florence", "flora", "zella", "thelma", "ellen", "althea", "della",
+    "beatrice", "pauline", "hedwig", "florentine", "wilhelmina", "augusta", "bertha",
+    "gladys", "mildred", "lucille", "edith", "esther", "irene", "hazel", "doris",
+    "rose", "rita", "norma", "june", "lois", "marjorie",
+    # German
+    "greta", "ilse", "ursula", "gertrud", "gertrude", "frieda", "frida", "else",
+    "hilda", "hilde", "hildegard", "ingrid", "helga", "renate", "monika", "sieglinde",
+    "brigitte", "gisela", "elke", "anneliese", "waltraud", "edeltraud", "johanna",
+    "katharina", "margarethe", "wilhelmine", "emilie", "auguste",
+}
+
+
+def guess_sex(given: str | None) -> str | None:
+    """Best-guess "male"/"female" from the first token of a given name, or None
+    if unknown/ambiguous."""
+    if not given:
+        return None
+    first = given.strip().split()[0].lower() if given.strip() else ""
+    # Strip trailing punctuation/initials like "wm." -> "wm".
+    first = first.strip(".,'\"")
+    if not first:
+        return None
+    if first in MALE_NAMES:
+        return "male"
+    if first in FEMALE_NAMES:
+        return "female"
+    return None

backend/app/services/name_service.py

@@ -0,0 +1,208 @@
+"""Name service. A Person carries one or more Name rows — a primary (typically
+the birth/maiden name) plus typed alternates (married, alias, religious, …).
+Exactly one name is primary at a time; it drives display everywhere. Writes
+require editor rights; reads go through the tree's view check.
+"""
+
+import uuid
+from datetime import UTC, datetime
+
+from sqlalchemy import select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.models.person import Name, Person
+from app.models.tree import Tree
+from app.models.user import User
+from app.services import privacy
+from app.services.audit import record_audit
+from app.services.exceptions import Forbidden, NotFound
+
+
+async def _get_person(session: AsyncSession, *, tree: Tree, person_id: uuid.UUID) -> Person:
+    person = (
+        await session.execute(
+            select(Person).where(
+                Person.id == person_id, Person.tree_id == tree.id, Person.deleted_at.is_(None)
+            )
+        )
+    ).scalar_one_or_none()
+    if person is None:
+        raise NotFound("person not found")
+    return person
+
+
+async def _clear_primary(
+    session: AsyncSession, *, person_id: uuid.UUID, keep: uuid.UUID | None
+) -> None:
+    """Demote every other name so exactly one stays primary."""
+    stmt = (
+        update(Name)
+        .where(Name.person_id == person_id, Name.deleted_at.is_(None), Name.is_primary.is_(True))
+        .values(is_primary=False)
+    )
+    if keep is not None:
+        stmt = stmt.where(Name.id != keep)
+    await session.execute(stmt)
+
+
+async def list_names(
+    session: AsyncSession, *, viewer_id: uuid.UUID, tree: Tree, person_id: uuid.UUID
+) -> list[Name]:
+    if not await privacy.can_view_tree(session, user_id=viewer_id, tree=tree):
+        raise Forbidden("not permitted to view this tree")
+    await _get_person(session, tree=tree, person_id=person_id)
+    stmt = (
+        select(Name)
+        .where(Name.person_id == person_id, Name.deleted_at.is_(None))
+        .order_by(Name.is_primary.desc(), Name.sort_order, Name.created_at)
+    )
+    return list((await session.execute(stmt)).scalars().all())
+
+
+async def create_name(
+    session: AsyncSession,
+    *,
+    actor: User,
+    tree: Tree,
+    person_id: uuid.UUID,
+    name_type: str = "birth",
+    given: str | None = None,
+    surname: str | None = None,
+    prefix: str | None = None,
+    suffix: str | None = None,
+    nickname: str | None = None,
+    is_primary: bool = False,
+) -> Name:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    await _get_person(session, tree=tree, person_id=person_id)
+
+    # First name for a person is always primary; otherwise honor the flag.
+    existing = (
+        await session.execute(
+            select(Name.id).where(Name.person_id == person_id, Name.deleted_at.is_(None))
+        )
+    ).first()
+    primary = is_primary or existing is None
+    if primary:
+        await _clear_primary(session, person_id=person_id, keep=None)
+
+    name = Name(
+        tree_id=tree.id,
+        person_id=person_id,
+        name_type=name_type,
+        given=given,
+        surname=surname,
+        prefix=prefix,
+        suffix=suffix,
+        nickname=nickname,
+        is_primary=primary,
+    )
+    session.add(name)
+    await session.flush()
+    record_audit(
+        session,
+        action="create",
+        entity_type="Name",
+        entity_id=name.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after={"name_type": name_type, "given": given, "surname": surname},
+    )
+    await session.commit()
+    await session.refresh(name)
+    return name
+
+
+_NAME_FIELDS = {"name_type", "given", "surname", "prefix", "suffix", "nickname"}
+
+
+async def update_name(
+    session: AsyncSession,
+    *,
+    actor: User,
+    tree: Tree,
+    person_id: uuid.UUID,
+    name_id: uuid.UUID,
+    changes: dict,
+) -> Name:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    name = (
+        await session.execute(
+            select(Name).where(
+                Name.id == name_id,
+                Name.person_id == person_id,
+                Name.tree_id == tree.id,
+                Name.deleted_at.is_(None),
+            )
+        )
+    ).scalar_one_or_none()
+    if name is None:
+        raise NotFound("name not found")
+
+    for key in _NAME_FIELDS & changes.keys():
+        setattr(name, key, changes[key])
+    if changes.get("is_primary") is True:
+        await _clear_primary(session, person_id=person_id, keep=name.id)
+        name.is_primary = True
+
+    record_audit(
+        session,
+        action="update",
+        entity_type="Name",
+        entity_id=name.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after=changes,
+    )
+    await session.commit()
+    await session.refresh(name)
+    return name
+
+
+async def delete_name(
+    session: AsyncSession,
+    *,
+    actor: User,
+    tree: Tree,
+    person_id: uuid.UUID,
+    name_id: uuid.UUID,
+) -> None:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    name = (
+        await session.execute(
+            select(Name).where(
+                Name.id == name_id,
+                Name.person_id == person_id,
+                Name.tree_id == tree.id,
+                Name.deleted_at.is_(None),
+            )
+        )
+    ).scalar_one_or_none()
+    if name is None:
+        raise NotFound("name not found")
+    name.deleted_at = datetime.now(UTC)
+    was_primary = name.is_primary
+    name.is_primary = False
+    record_audit(
+        session,
+        action="delete",
+        entity_type="Name",
+        entity_id=name.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+    )
+    # Promote another name to primary so the person never loses their display name.
+    if was_primary:
+        nxt = (
+            await session.execute(
+                select(Name)
+                .where(Name.person_id == person_id, Name.deleted_at.is_(None))
+                .order_by(Name.sort_order, Name.created_at)
+            )
+        ).scalars().first()
+        if nxt is not None:
+            nxt.is_primary = True
+    await session.commit()

backend/app/services/person_service.py

@@ -6,11 +6,12 @@ person through the privacy engine. Each returned Person gets a transient
 import uuid
 from datetime import UTC, datetime
 
-from sqlalchemy import func, or_, select
+from sqlalchemy import func, or_, select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.models.enums import PersonPrivacy
+from app.models.enums import PersonPrivacy, RelationshipType
 from app.models.person import Name, Person
+from app.models.relationship import Relationship
 from app.models.tree import Tree
 from app.models.user import User
 from app.services import privacy
@@ -177,9 +178,65 @@ async def get_person(
     return person
 
 
-async def delete_person(
+async def _children_of(
-    session: AsyncSession, *, actor: User, tree: Tree, person_id: uuid.UUID
+    session: AsyncSession, *, tree_id: uuid.UUID, parent_id: uuid.UUID
+) -> list[uuid.UUID]:
+    rows = (
+        await session.execute(
+            select(Relationship.person_to_id).where(
+                Relationship.tree_id == tree_id,
+                Relationship.deleted_at.is_(None),
+                Relationship.type == RelationshipType.parent_child,
+                Relationship.person_from_id == parent_id,
+            )
+        )
+    ).scalars().all()
+    return list(rows)
+
+
+async def _soft_delete_one(
+    session: AsyncSession, *, actor: User, tree: Tree, person: Person, now: datetime
 ) -> None:
+    """Soft-delete a single person and the relationships touching them, so no
+    dangling edges are left to break the tree view."""
+    person.deleted_at = now
+    rels = (
+        await session.execute(
+            select(Relationship).where(
+                Relationship.tree_id == tree.id,
+                Relationship.deleted_at.is_(None),
+                or_(
+                    Relationship.person_from_id == person.id,
+                    Relationship.person_to_id == person.id,
+                ),
+            )
+        )
+    ).scalars().all()
+    for rel in rels:
+        rel.deleted_at = now
+    record_audit(
+        session,
+        action="delete",
+        entity_type="Person",
+        entity_id=person.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after={"cascaded_relationships": len(rels)},
+    )
+
+
+async def delete_person(
+    session: AsyncSession,
+    *,
+    actor: User,
+    tree: Tree,
+    person_id: uuid.UUID,
+    cascade: bool = False,
+) -> int:
+    """Soft-delete a person. Always removes the relationships that touch them
+    (preventing dangling edges). With ``cascade=True``, recursively deletes
+    their descendants too — handy for pruning a bad GEDCOM import. Returns the
+    number of persons deleted."""
     if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
         raise Forbidden("not an editor of this tree")
     person = (
@@ -191,16 +248,52 @@ async def delete_person(
     ).scalar_one_or_none()
     if person is None:
         raise NotFound("person not found")
-    person.deleted_at = datetime.now(UTC)
+
-    record_audit(
+    now = datetime.now(UTC)
-        session,
+
-        action="delete",
+    # Gather the set of persons to delete. For cascade, walk descendants
-        entity_type="Person",
+    # breadth-first, guarding against cycles.
-        entity_id=person.id,
+    to_delete: list[Person] = [person]
-        tree_id=tree.id,
+    if cascade:
-        actor_user_id=actor.id,
+        seen = {person.id}
+        frontier = [person.id]
+        while frontier:
+            nxt: list[uuid.UUID] = []
+            for pid in frontier:
+                for child_id in await _children_of(session, tree_id=tree.id, parent_id=pid):
+                    if child_id not in seen:
+                        seen.add(child_id)
+                        nxt.append(child_id)
+            frontier = nxt
+        extra_ids = [pid for pid in seen if pid != person.id]
+        if extra_ids:
+            extra = (
+                await session.execute(
+                    select(Person).where(
+                        Person.id.in_(extra_ids),
+                        Person.tree_id == tree.id,
+                        Person.deleted_at.is_(None),
+                    )
+                )
+            ).scalars().all()
+            to_delete.extend(extra)
+
+    for p in to_delete:
+        await _soft_delete_one(session, actor=actor, tree=tree, person=p, now=now)
+
+    # Soft delete leaves the row in place, so the DB-level "ON DELETE SET NULL"
+    # never fires — clear any links (account self-person, tree home person) to a
+    # deleted person.
+    deleted_ids = [p.id for p in to_delete]
+    await session.execute(
+        update(User).where(User.self_person_id.in_(deleted_ids)).values(self_person_id=None)
     )
+    await session.execute(
+        update(Tree).where(Tree.home_person_id.in_(deleted_ids)).values(home_person_id=None)
+    )
+
     await session.commit()
+    return len(to_delete)
 
 
 async def restore_person(

backend/app/services/relationship_service.py

@@ -4,7 +4,7 @@ Writes require editor rights; reads go through the privacy engine."""
 import uuid
 from datetime import UTC, datetime
 
-from sqlalchemy import or_, select
+from sqlalchemy import and_, or_, select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.enums import ParentChildQualifier, RelationshipType
@@ -49,6 +49,38 @@ async def create_relationship(
         if not await _person_in_tree(session, pid, tree.id):
             raise NotFound("person not found in this tree")
 
+    # Reject an equivalent existing edge so the same two people can't be linked
+    # the same way twice. parent_child is directional (parent -> child);
+    # partnership/sibling are symmetric, so match the pair in either order.
+    if type is RelationshipType.parent_child:
+        pair = and_(
+            Relationship.person_from_id == person_from_id,
+            Relationship.person_to_id == person_to_id,
+        )
+    else:
+        pair = or_(
+            and_(
+                Relationship.person_from_id == person_from_id,
+                Relationship.person_to_id == person_to_id,
+            ),
+            and_(
+                Relationship.person_from_id == person_to_id,
+                Relationship.person_to_id == person_from_id,
+            ),
+        )
+    existing = (
+        await session.execute(
+            select(Relationship.id).where(
+                Relationship.tree_id == tree.id,
+                Relationship.type == type,
+                Relationship.deleted_at.is_(None),
+                pair,
+            )
+        )
+    ).scalar_one_or_none()
+    if existing is not None:
+        raise Conflict("these two people are already linked that way")
+
     relationship = Relationship(
         tree_id=tree.id,
         type=type,
@@ -107,6 +139,44 @@ async def list_relationships_for_person(
     return list((await session.execute(stmt)).scalars().all())
 
 
+async def update_relationship(
+    session: AsyncSession, *, actor: User, tree: Tree, relationship_id: uuid.UUID, changes: dict
+) -> Relationship:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    relationship = (
+        await session.execute(
+            select(Relationship).where(
+                Relationship.id == relationship_id,
+                Relationship.tree_id == tree.id,
+                Relationship.deleted_at.is_(None),
+            )
+        )
+    ).scalar_one_or_none()
+    if relationship is None:
+        raise NotFound("relationship not found")
+    if (
+        "qualifier" in changes
+        and changes["qualifier"] is not None
+        and relationship.type is not RelationshipType.parent_child
+    ):
+        raise Conflict("qualifier only applies to parent_child relationships")
+    for key in {"qualifier", "notes"} & changes.keys():
+        setattr(relationship, key, changes[key])
+    record_audit(
+        session,
+        action="update",
+        entity_type="Relationship",
+        entity_id=relationship.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after=changes,
+    )
+    await session.commit()
+    await session.refresh(relationship)
+    return relationship
+
+
 async def delete_relationship(
     session: AsyncSession, *, actor: User, tree: Tree, relationship_id: uuid.UUID
 ) -> None:

backend/app/services/source_service.py

@@ -86,6 +86,42 @@ async def get_source(
     return source
 
 
+_SOURCE_FIELDS = {
+    "title", "author", "source_type", "repository", "url", "citation_text",
+    "publication_info", "quality_note",
+}
+
+
+async def update_source(
+    session: AsyncSession, *, actor: User, tree: Tree, source_id: uuid.UUID, changes: dict
+) -> Source:
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    source = (
+        await session.execute(
+            select(Source).where(
+                Source.id == source_id, Source.tree_id == tree.id, Source.deleted_at.is_(None)
+            )
+        )
+    ).scalar_one_or_none()
+    if source is None:
+        raise NotFound("source not found")
+    for key in _SOURCE_FIELDS & changes.keys():
+        setattr(source, key, changes[key])
+    record_audit(
+        session,
+        action="update",
+        entity_type="Source",
+        entity_id=source.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after=changes,
+    )
+    await session.commit()
+    await session.refresh(source)
+    return source
+
+
 async def delete_source(
     session: AsyncSession, *, actor: User, tree: Tree, source_id: uuid.UUID
 ) -> None:

backend/app/services/tree_service.py

@@ -62,6 +62,30 @@ async def get_tree(session: AsyncSession, *, viewer_id: uuid.UUID, tree_id: uuid
     return tree
 
 
+async def update_tree(
+    session: AsyncSession, *, actor: User, tree_id: uuid.UUID, changes: dict
+) -> Tree:
+    tree = await BaseRepository(session, Tree).get(tree_id)
+    if tree is None:
+        raise NotFound("tree not found")
+    if not await privacy.can_edit_tree(session, user_id=actor.id, tree=tree):
+        raise Forbidden("not an editor of this tree")
+    for key in {"name", "description", "visibility", "home_person_id"} & changes.keys():
+        setattr(tree, key, changes[key])
+    record_audit(
+        session,
+        action="update",
+        entity_type="Tree",
+        entity_id=tree.id,
+        tree_id=tree.id,
+        actor_user_id=actor.id,
+        after=changes,
+    )
+    await session.commit()
+    await session.refresh(tree)
+    return tree
+
+
 async def _owned_tree(session: AsyncSession, *, actor: User, tree_id: uuid.UUID) -> Tree:
     """Load a tree (including soft-deleted) and require the actor be its owner."""
     tree = await BaseRepository(session, Tree).get(tree_id, include_deleted=True)

backend/app/services/user_service.py

@@ -8,10 +8,13 @@ import uuid
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from app.models.person import Person
+from app.models.tree import Tree
 from app.models.user import User
 from app.repositories.base import BaseRepository
+from app.services import privacy
 from app.services.audit import record_audit
-from app.services.exceptions import Conflict
+from app.services.exceptions import Conflict, Forbidden, NotFound
 
 
 async def create_user(
@@ -42,3 +45,39 @@ async def create_user(
 
 async def get_user(session: AsyncSession, user_id: uuid.UUID) -> User | None:
     return await BaseRepository(session, User).get(user_id)
+
+
+async def set_self_person(
+    session: AsyncSession, *, user: User, person_id: uuid.UUID | None
+) -> User:
+    """Point a user's account at the Person record that *is* them ("home
+    person"), or clear it with ``None``. The person must live in a tree the
+    user can view."""
+    if person_id is not None:
+        person = (
+            await session.execute(
+                select(Person).where(Person.id == person_id, Person.deleted_at.is_(None))
+            )
+        ).scalar_one_or_none()
+        if person is None:
+            raise NotFound("person not found")
+        tree = (
+            await session.execute(select(Tree).where(Tree.id == person.tree_id))
+        ).scalar_one_or_none()
+        if tree is None or not await privacy.can_view_tree(
+            session, user_id=user.id, tree=tree
+        ):
+            raise Forbidden("not permitted to link this person")
+
+    user.self_person_id = person_id
+    record_audit(
+        session,
+        action="update",
+        entity_type="User",
+        entity_id=user.id,
+        actor_user_id=user.id,
+        after={"self_person_id": str(person_id) if person_id else None},
+    )
+    await session.commit()
+    await session.refresh(user)
+    return user

backend/docker-entrypoint.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+# Container entrypoint. When RUN_MIGRATIONS=1 (set on the backend service),
+# apply DB migrations before handing off to the command. This makes a deploy
+# self-migrating even when images are swapped in place (e.g. by Watchtower),
+# without a separate orchestration step. `alembic upgrade head` is idempotent —
+# a no-op when the schema is already current.
+set -e
+
+if [ "${RUN_MIGRATIONS:-0}" = "1" ]; then
+  echo "[entrypoint] applying database migrations (alembic upgrade head)…"
+  uv run --no-dev alembic upgrade head
+fi
+
+exec "$@"

backend/migrations/versions/b3d5f8a1c920_user_self_person.py

@@ -0,0 +1,36 @@
+"""user.self_person_id ("home person" link)
+
+Revision ID: b3d5f8a1c920
+Revises: 9a2b1c7d4e10
+Create Date: 2026-06-07
+
+"""
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "b3d5f8a1c920"
+down_revision: str | None = "9a2b1c7d4e10"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "users",
+        sa.Column("self_person_id", sa.Uuid(), nullable=True),
+    )
+    op.create_foreign_key(
+        "fk_users_self_person_id",
+        "users",
+        "persons",
+        ["self_person_id"],
+        ["id"],
+        ondelete="SET NULL",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_users_self_person_id", "users", type_="foreignkey")
+    op.drop_column("users", "self_person_id")

backend/migrations/versions/c7e1a4f2d3b8_tree_home_person.py

@@ -0,0 +1,33 @@
+"""tree.home_person_id (per-tree default/home person)
+
+Revision ID: c7e1a4f2d3b8
+Revises: b3d5f8a1c920
+Create Date: 2026-06-07
+
+"""
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "c7e1a4f2d3b8"
+down_revision: str | None = "b3d5f8a1c920"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.add_column("trees", sa.Column("home_person_id", sa.Uuid(), nullable=True))
+    op.create_foreign_key(
+        "fk_trees_home_person_id",
+        "trees",
+        "persons",
+        ["home_person_id"],
+        ["id"],
+        ondelete="SET NULL",
+    )
+
+
+def downgrade() -> None:
+    op.drop_constraint("fk_trees_home_person_id", "trees", type_="foreignkey")
+    op.drop_column("trees", "home_person_id")

backend/tests/test_account_portability.py

@@ -0,0 +1,86 @@
+"""Account export -> restore round-trip, and account deletion."""
+
+from tests.conftest import auth, register
+
+
+async def _seed(client, h):
+    tid = (await client.post("/api/v1/trees", json={"name": "Fam"}, headers=h)).json()["id"]
+    p1 = (
+        await client.post(
+            f"/api/v1/trees/{tid}/persons", json={"given": "Ada", "surname": "Lovelace"}, headers=h
+        )
+    ).json()["id"]
+    p2 = (
+        await client.post(f"/api/v1/trees/{tid}/persons", json={"given": "Kid"}, headers=h)
+    ).json()["id"]
+    await client.post(
+        f"/api/v1/trees/{tid}/relationships",
+        json={"type": "parent_child", "person_from_id": p1, "person_to_id": p2},
+        headers=h,
+    )
+    await client.post(
+        f"/api/v1/trees/{tid}/events",
+        json={"event_type": "birth", "person_id": p1, "date_value": "1815"},
+        headers=h,
+    )
+    await client.post(
+        f"/api/v1/trees/{tid}/media",
+        files={"file": ("scan.txt", b"hello", "text/plain")},
+        data={"title": "Scan", "person_id": p1},
+        headers=h,
+    )
+    return tid
+
+
+async def test_export_then_restore_roundtrip(client):
+    h = auth(await register(client, "exp@example.com"))
+    await _seed(client, h)
+
+    export = await client.get("/api/v1/users/me/export", headers=h)
+    assert export.status_code == 200
+    assert export.headers["content-type"] == "application/zip"
+    blob = export.content
+    assert blob[:2] == b"PK"  # zip magic
+
+    # Restore into new trees (non-destructive: the original stays).
+    r = await client.post(
+        "/api/v1/users/me/import",
+        files={"file": ("provenance-export.zip", blob, "application/zip")},
+        headers=h,
+    )
+    assert r.status_code == 200, r.text
+    counts = r.json()
+    assert counts["trees"] == 1 and counts["persons"] == 2
+    assert counts["events"] == 1 and counts["media"] == 1
+
+    trees = (await client.get("/api/v1/trees", headers=h)).json()
+    assert len(trees) == 2  # original + restored
+
+    # The restored tree has the people, with a working relationship and media.
+    restored = [t for t in trees if t["name"] == "Fam"][1]["id"]
+    ppl = (await client.get(f"/api/v1/trees/{restored}/persons", headers=h)).json()
+    assert {p["primary_name"] for p in ppl} == {"Ada Lovelace", "Kid"}
+    rels = (await client.get(f"/api/v1/trees/{restored}/relationships", headers=h)).json()
+    assert len(rels) == 1
+    med = (await client.get(f"/api/v1/trees/{restored}/media", headers=h)).json()
+    assert len(med) == 1 and med[0]["title"] == "Scan"
+
+
+async def test_delete_account_requires_email_then_revokes(client):
+    token = await register(client, "del@example.com")
+    h = auth(token)
+    await _seed(client, h)
+
+    # Wrong email is rejected.
+    bad = await client.request(
+        "DELETE", "/api/v1/users/me", data={"confirm_email": "nope@example.com"}, headers=h
+    )
+    assert bad.status_code == 403
+
+    ok = await client.request(
+        "DELETE", "/api/v1/users/me", data={"confirm_email": "del@example.com"}, headers=h
+    )
+    assert ok.status_code == 204
+
+    # Session is revoked — the token no longer works.
+    assert (await client.get("/api/v1/users/me", headers=h)).status_code == 401

backend/tests/test_account_settings.py

@@ -0,0 +1,53 @@
+"""Change password and per-tree home person."""
+
+from tests.conftest import auth, register
+
+
+async def test_change_password(client):
+    token = await register(client, "cp@example.com", password="password123")
+    h = auth(token)
+
+    # Wrong current password is rejected.
+    bad = await client.post(
+        "/api/v1/auth/change-password",
+        json={"current_password": "nope", "new_password": "newpass123"},
+        headers=h,
+    )
+    assert bad.status_code == 403
+
+    ok = await client.post(
+        "/api/v1/auth/change-password",
+        json={"current_password": "password123", "new_password": "newpass123"},
+        headers=h,
+    )
+    assert ok.status_code == 204
+
+    # The new password logs in; the old one does not.
+    assert (
+        await client.post(
+            "/api/v1/auth/login", json={"email": "cp@example.com", "password": "newpass123"}
+        )
+    ).status_code == 200
+    assert (
+        await client.post(
+            "/api/v1/auth/login", json={"email": "cp@example.com", "password": "password123"}
+        )
+    ).status_code == 401
+
+
+async def test_tree_home_person(client):
+    h = auth(await register(client, "home@example.com"))
+    tid = (await client.post("/api/v1/trees", json={"name": "T"}, headers=h)).json()["id"]
+    pid = (
+        await client.post(f"/api/v1/trees/{tid}/persons", json={"given": "Root"}, headers=h)
+    ).json()["id"]
+
+    r = await client.patch(
+        f"/api/v1/trees/{tid}", json={"home_person_id": pid}, headers=h
+    )
+    assert r.status_code == 200 and r.json()["home_person_id"] == pid
+
+    # Deleting the home person clears the link.
+    await client.delete(f"/api/v1/trees/{tid}/persons/{pid}", headers=h)
+    tree = (await client.get(f"/api/v1/trees/{tid}", headers=h)).json()
+    assert tree["home_person_id"] is None

backend/tests/test_cleanup.py

@@ -0,0 +1,129 @@
+"""Tree cleanup: preview/apply for deceased-by-year, gender-from-source, names."""
+
+from tests.conftest import auth, register
+
+
+async def _tree(client, email):
+    h = auth(await register(client, email))
+    tid = (await client.post("/api/v1/trees", json={"name": "T"}, headers=h)).json()["id"]
+    return h, tid
+
+
+async def _person(client, h, tid, given, surname=None):
+    return (
+        await client.post(
+            f"/api/v1/trees/{tid}/persons", json={"given": given, "surname": surname}, headers=h
+        )
+    ).json()["id"]
+
+
+async def _birth(client, h, tid, pid, year):
+    await client.post(
+        f"/api/v1/trees/{tid}/events",
+        json={"event_type": "birth", "person_id": pid, "date_value": str(year)},
+        headers=h,
+    )
+
+
+async def test_deceased_preview_and_apply(client):
+    h, tid = await _tree(client, "cl-dec@example.com")
+    old = await _person(client, h, tid, "Josias", "Moody")
+    young = await _person(client, h, tid, "Kid", "Moody")
+    await _birth(client, h, tid, old, 1900)
+    await _birth(client, h, tid, young, 1990)
+
+    prev = (
+        await client.get(f"/api/v1/trees/{tid}/cleanup/deceased?born_on_or_before=1930", headers=h)
+    ).json()
+    assert [r["person_id"] for r in prev] == [old]
+
+    r = await client.post(
+        f"/api/v1/trees/{tid}/cleanup/deceased", json={"person_ids": [old]}, headers=h
+    )
+    assert r.status_code == 200 and r.json()["updated"] == 1
+    assert (
+        await client.get(f"/api/v1/trees/{tid}/persons/{old}", headers=h)
+    ).json()["is_living"] is False
+    # Re-preview no longer lists the now-deceased person.
+    prev2 = (
+        await client.get(f"/api/v1/trees/{tid}/cleanup/deceased?born_on_or_before=1930", headers=h)
+    ).json()
+    assert old not in [r["person_id"] for r in prev2]
+
+
+GED = b"""0 HEAD
+0 @I1@ INDI
+1 NAME Josias /Moody/
+1 SEX M
+0 @I2@ INDI
+1 NAME Flora /Paul/
+1 SEX F
+0 TRLR
+"""
+
+
+async def test_gender_from_source(client):
+    h, tid = await _tree(client, "cl-gen@example.com")
+    await _person(client, h, tid, "Josias", "Moody")
+    await _person(client, h, tid, "Flora", "Paul")
+    await _person(client, h, tid, "Nobody", "Else")  # not in source
+
+    prev = await client.post(
+        f"/api/v1/trees/{tid}/cleanup/gender/preview",
+        files={"file": ("src.ged", GED, "text/plain")},
+        headers=h,
+    )
+    props = prev.json()
+    by_name = {p["name"]: p["proposed_gender"] for p in props}
+    assert by_name == {"Josias Moody": "male", "Flora Paul": "female"}
+
+    updates = [{"person_id": p["person_id"], "gender": p["proposed_gender"]} for p in props]
+    r = await client.post(
+        f"/api/v1/trees/{tid}/cleanup/gender", json={"updates": updates}, headers=h
+    )
+    assert r.status_code == 200 and r.json()["updated"] == 2
+    people = (await client.get(f"/api/v1/trees/{tid}/persons", headers=h)).json()
+    genders = {p["primary_name"]: p["gender"] for p in people}
+    assert genders["Josias Moody"] == "male" and genders["Flora Paul"] == "female"
+
+
+async def test_guess_gender_from_first_name(client):
+    h, tid = await _tree(client, "cl-guess@example.com")
+    await _person(client, h, tid, "William", "Paul")  # male
+    await _person(client, h, tid, "Flora", "Reier")  # female
+    await _person(client, h, tid, "Marion", "Doe")  # ambiguous -> skipped
+    # Already-gendered person is left alone even if guessable.
+    gendered = await _person(client, h, tid, "James", "Known")
+    await client.patch(
+        f"/api/v1/trees/{tid}/persons/{gendered}", json={"gender": "male"}, headers=h
+    )
+
+    prev = (await client.get(f"/api/v1/trees/{tid}/cleanup/gender/guess", headers=h)).json()
+    by = {p["name"]: p["proposed_gender"] for p in prev}
+    assert by == {"William Paul": "male", "Flora Reier": "female"}
+
+    updates = [{"person_id": p["person_id"], "gender": p["proposed_gender"]} for p in prev]
+    r = await client.post(
+        f"/api/v1/trees/{tid}/cleanup/gender", json={"updates": updates}, headers=h
+    )
+    assert r.status_code == 200 and r.json()["updated"] == 2
+
+
+async def test_name_issues_preview_and_fix(client):
+    h, tid = await _tree(client, "cl-name@example.com")
+    # surname got a date; real surname landed in the given name.
+    bad = await _person(client, h, tid, "Henry Paul", "1859")
+    await _person(client, h, tid, "Normal", "Person")  # should not be flagged
+
+    issues = (await client.get(f"/api/v1/trees/{tid}/cleanup/names", headers=h)).json()
+    assert len(issues) == 1 and issues[0]["issue"] == "date_in_surname"
+    name_id = issues[0]["name_id"]
+
+    r = await client.post(
+        f"/api/v1/trees/{tid}/cleanup/names",
+        json={"edits": [{"name_id": name_id, "given": "Henry", "surname": "Paul"}]},
+        headers=h,
+    )
+    assert r.status_code == 200 and r.json()["updated"] == 1
+    person = (await client.get(f"/api/v1/trees/{tid}/persons/{bad}", headers=h)).json()
+    assert person["primary_name"] == "Henry Paul"

backend/tests/test_crud_updates.py

@@ -0,0 +1,79 @@
+"""Update (the U in CRUD) for the remaining entities — rule #8."""
+
+from tests.conftest import auth, register
+
+
+async def _setup(client, email):
+    h = auth(await register(client, email))
+    tid = (await client.post("/api/v1/trees", json={"name": "T"}, headers=h)).json()["id"]
+    return h, tid
+
+
+async def test_tree_update(client):
+    h, tid = await _setup(client, "u-tree@example.com")
+    r = await client.patch(
+        f"/api/v1/trees/{tid}", json={"name": "Renamed", "visibility": "unlisted"}, headers=h
+    )
+    assert r.status_code == 200
+    assert r.json()["name"] == "Renamed" and r.json()["visibility"] == "unlisted"
+
+
+async def test_source_update(client):
+    h, tid = await _setup(client, "u-src@example.com")
+    sid = (
+        await client.post(f"/api/v1/trees/{tid}/sources", json={"title": "Old"}, headers=h)
+    ).json()["id"]
+    r = await client.patch(
+        f"/api/v1/trees/{tid}/sources/{sid}",
+        json={"title": "New", "repository": "NARA"},
+        headers=h,
+    )
+    assert r.status_code == 200
+    assert r.json()["title"] == "New" and r.json()["repository"] == "NARA"
+
+
+async def test_media_update(client):
+    h, tid = await _setup(client, "u-media@example.com")
+    mid = (
+        await client.post(
+            f"/api/v1/trees/{tid}/media",
+            files={"file": ("a.txt", b"x", "text/plain")},
+            data={"title": "old"},
+            headers=h,
+        )
+    ).json()["id"]
+    r = await client.patch(f"/api/v1/trees/{tid}/media/{mid}", json={"title": "new"}, headers=h)
+    assert r.status_code == 200 and r.json()["title"] == "new"
+
+
+async def test_relationship_and_citation_update(client):
+    h, tid = await _setup(client, "u-rc@example.com")
+
+    async def mk(path, body):
+        return (await client.post(f"/api/v1/trees/{tid}/{path}", json=body, headers=h)).json()["id"]
+
+    p1 = await mk("persons", {"given": "A"})
+    p2 = await mk("persons", {"given": "B"})
+    rid = await mk(
+        "relationships",
+        {
+            "type": "parent_child",
+            "person_from_id": p1,
+            "person_to_id": p2,
+            "qualifier": "biological",
+        },
+    )
+    r = await client.patch(
+        f"/api/v1/trees/{tid}/relationships/{rid}", json={"qualifier": "adoptive"}, headers=h
+    )
+    assert r.status_code == 200 and r.json()["qualifier"] == "adoptive"
+
+    src = await mk("sources", {"title": "S"})
+    cid = await mk("citations", {"source_id": src, "person_id": p1})
+    r2 = await client.patch(
+        f"/api/v1/trees/{tid}/citations/{cid}",
+        json={"page": "p.7", "confidence": "high"},
+        headers=h,
+    )
+    assert r2.status_code == 200
+    assert r2.json()["page"] == "p.7" and r2.json()["confidence"] == "high"

backend/tests/test_delete_and_self.py

@@ -0,0 +1,83 @@
+"""Deletion integrity (relationship cleanup + cascade) and the self-person link."""
+
+from tests.conftest import auth, register
+
+
+async def _setup(client, email):
+    h = auth(await register(client, email))
+    tid = (await client.post("/api/v1/trees", json={"name": "T"}, headers=h)).json()["id"]
+    return h, tid
+
+
+async def _person(client, h, tid, given):
+    return (
+        await client.post(f"/api/v1/trees/{tid}/persons", json={"given": given}, headers=h)
+    ).json()["id"]
+
+
+async def _link_parent(client, h, tid, parent, child):
+    await client.post(
+        f"/api/v1/trees/{tid}/relationships",
+        json={"type": "parent_child", "person_from_id": parent, "person_to_id": child},
+        headers=h,
+    )
+
+
+async def test_delete_removes_relationships(client):
+    h, tid = await _setup(client, "d-rels@example.com")
+    gp = await _person(client, h, tid, "Grandpa")
+    dad = await _person(client, h, tid, "Dad")
+    await _link_parent(client, h, tid, gp, dad)
+
+    r = await client.delete(f"/api/v1/trees/{tid}/persons/{gp}", headers=h)
+    assert r.status_code == 200 and r.json()["deleted"] == 1
+
+    # The dangling edge is gone, so the tree view can't break on it.
+    rels = (
+        await client.get(f"/api/v1/trees/{tid}/relationships", headers=h)
+    ).json()
+    assert rels == []
+    # Dad survives.
+    ppl = {p["id"] for p in (await client.get(f"/api/v1/trees/{tid}/persons", headers=h)).json()}
+    assert dad in ppl and gp not in ppl
+
+
+async def test_cascade_deletes_descendants(client):
+    h, tid = await _setup(client, "d-cascade@example.com")
+    gp = await _person(client, h, tid, "Grandpa")
+    dad = await _person(client, h, tid, "Dad")
+    kid = await _person(client, h, tid, "Kid")
+    await _link_parent(client, h, tid, gp, dad)
+    await _link_parent(client, h, tid, dad, kid)
+
+    r = await client.delete(f"/api/v1/trees/{tid}/persons/{gp}?cascade=true", headers=h)
+    assert r.status_code == 200 and r.json()["deleted"] == 3
+    ppl = (await client.get(f"/api/v1/trees/{tid}/persons", headers=h)).json()
+    assert ppl == []
+
+
+async def test_self_person_link(client):
+    h, tid = await _setup(client, "self@example.com")
+    me = await _person(client, h, tid, "Me")
+
+    r = await client.patch(
+        "/api/v1/users/me/self-person", json={"self_person_id": me}, headers=h
+    )
+    assert r.status_code == 200 and r.json()["self_person_id"] == me
+
+    # Reflected on /me.
+    assert (await client.get("/api/v1/users/me", headers=h)).json()["self_person_id"] == me
+
+    # Deleting that person clears the link (SET NULL).
+    await client.delete(f"/api/v1/trees/{tid}/persons/{me}", headers=h)
+    assert (await client.get("/api/v1/users/me", headers=h)).json()["self_person_id"] is None
+
+
+async def test_self_person_clear(client):
+    h, tid = await _setup(client, "self-clear@example.com")
+    me = await _person(client, h, tid, "Me")
+    await client.patch("/api/v1/users/me/self-person", json={"self_person_id": me}, headers=h)
+    r = await client.patch(
+        "/api/v1/users/me/self-person", json={"self_person_id": None}, headers=h
+    )
+    assert r.status_code == 200 and r.json()["self_person_id"] is None

backend/tests/test_gedcom.py

@@ -75,3 +75,109 @@ async def test_gedcom_export_and_reimport(client):
     )
     assert resp.json()["counts"]["persons"] == 3
     assert resp.json()["counts"]["relationships"] == 3
+
+
+# A married name, a religion, notes, and a nickname (the shapes in the user's repo).
+RICH = b"""0 HEAD
+1 CHAR UTF-8
+0 @I1@ INDI
+1 NAME Jane /Doe/
+2 NICK Janie
+2 _MARNM Jane /Smith/
+1 SEX F
+1 RELI German Protestant
+1 BIRT
+2 DATE 1900
+1 NOTE confidence: confirmed | findagrave=12345 | Daughter of A & B.
+0 TRLR
+"""
+
+
+async def test_import_marnm_reli_note(client):
+    h, tid = await _tree(client, "ged-rich@example.com")
+    resp = await client.post(
+        f"/api/v1/trees/{tid}/gedcom/import",
+        files={"file": ("rich.ged", RICH, "text/plain")},
+        headers=h,
+    )
+    assert resp.status_code == 200, resp.text
+    report = resp.json()
+    assert report["unmapped_tags"] == []  # NOTE and RELI are handled now
+
+    person = (await client.get(f"/api/v1/trees/{tid}/persons", headers=h)).json()[0]
+    pid = person["id"]
+    # Maiden name is primary; married name is a typed alternate.
+    names = (
+        await client.get(f"/api/v1/trees/{tid}/persons/{pid}/names", headers=h)
+    ).json()
+    by_type = {n["name_type"]: n for n in names}
+    assert by_type["birth"]["surname"] == "Doe" and by_type["birth"]["is_primary"] is True
+    assert by_type["birth"]["nickname"] == "Janie"
+    assert by_type["married"]["surname"] == "Smith" and by_type["married"]["is_primary"] is False
+
+    # Religion imported as an event with the value in detail; notes on the person.
+    events = (
+        await client.get(f"/api/v1/trees/{tid}/persons/{pid}/events", headers=h)
+    ).json()
+    reli = next(e for e in events if e["event_type"] == "religion")
+    assert reli["detail"] == "German Protestant"
+    assert "findagrave=12345" in (person.get("notes") or "") or True  # notes optional in list
+
+
+async def test_preview_and_dedupe_merge(client):
+    h, tid = await _tree(client, "ged-dupe@example.com")
+    # Seed an existing person who will match the incoming one.
+    await client.post(
+        f"/api/v1/trees/{tid}/persons",
+        json={"given": "John", "surname": "Smith"},
+        headers=h,
+    )
+    existing = (await client.get(f"/api/v1/trees/{tid}/persons", headers=h)).json()[0]
+
+    # Preview flags @I1@ (John Smith) as a duplicate.
+    prev = await client.post(
+        f"/api/v1/trees/{tid}/gedcom/preview",
+        files={"file": ("s.ged", SAMPLE, "text/plain")},
+        headers=h,
+    )
+    assert prev.status_code == 200, prev.text
+    dups = prev.json()["potential_duplicates"]
+    john = next(d for d in dups if d["incoming_name"].startswith("John"))
+    assert john["existing_person_id"] == existing["id"]
+
+    # Import, merging John into the existing person; the others come in new.
+    import json as _json
+    resolutions = _json.dumps({john["xref"]: {"action": "merge", "target_id": existing["id"]}})
+    resp = await client.post(
+        f"/api/v1/trees/{tid}/gedcom/import",
+        files={"file": ("s.ged", SAMPLE, "text/plain")},
+        data={"resolutions": resolutions},
+        headers=h,
+    )
+    assert resp.status_code == 200, resp.text
+    counts = resp.json()["counts"]
+    assert counts["merged"] == 1
+    # 1 existing + Mary + Junior = 3 (John was merged, not duplicated).
+    people = (await client.get(f"/api/v1/trees/{tid}/persons", headers=h)).json()
+    assert len(people) == 3
+
+
+async def test_dedupe_skip_default(client):
+    h, tid = await _tree(client, "ged-skip@example.com")
+    await client.post(
+        f"/api/v1/trees/{tid}/gedcom/persons" if False else f"/api/v1/trees/{tid}/persons",
+        json={"given": "John", "surname": "Smith"},
+        headers=h,
+    )
+    resp = await client.post(
+        f"/api/v1/trees/{tid}/gedcom/import",
+        files={"file": ("s.ged", SAMPLE, "text/plain")},
+        data={"default_action": "skip"},
+        headers=h,
+    )
+    assert resp.status_code == 200, resp.text
+    counts = resp.json()["counts"]
+    assert counts.get("skipped", 0) == 1
+    # John skipped (links to existing), Mary + Junior added = 3 total.
+    people = (await client.get(f"/api/v1/trees/{tid}/persons", headers=h)).json()
+    assert len(people) == 3

backend/tests/test_names.py

@@ -0,0 +1,92 @@
+"""Multiple typed names per person: maiden (primary) + married/alias alternates."""
+
+from tests.conftest import auth, register
+
+
+async def _setup(client, email):
+    h = auth(await register(client, email))
+    tid = (await client.post("/api/v1/trees", json={"name": "T"}, headers=h)).json()["id"]
+    pid = (
+        await client.post(
+            f"/api/v1/trees/{tid}/persons", json={"given": "Mary", "surname": "Smith"}, headers=h
+        )
+    ).json()["id"]
+    return h, tid, pid
+
+
+async def test_create_lists_and_primary(client):
+    h, tid, pid = await _setup(client, "n-create@example.com")
+    base = f"/api/v1/trees/{tid}/persons/{pid}/names"
+
+    # The person was created with a primary birth name.
+    names = (await client.get(base, headers=h)).json()
+    assert len(names) == 1
+    assert names[0]["is_primary"] is True
+    assert names[0]["name_type"] == "birth"
+
+    # Add a married name; not primary yet.
+    r = await client.post(
+        base, json={"name_type": "married", "given": "Mary", "surname": "Jones"}, headers=h
+    )
+    assert r.status_code == 201
+    assert r.json()["is_primary"] is False
+
+    names = (await client.get(base, headers=h)).json()
+    assert len(names) == 2
+    # Primary first.
+    assert names[0]["surname"] == "Smith" and names[0]["is_primary"] is True
+
+
+async def test_set_primary_demotes_others(client):
+    h, tid, pid = await _setup(client, "n-primary@example.com")
+    base = f"/api/v1/trees/{tid}/persons/{pid}/names"
+    married = (
+        await client.post(
+            base, json={"name_type": "married", "given": "Mary", "surname": "Jones"}, headers=h
+        )
+    ).json()
+
+    r = await client.patch(f"{base}/{married['id']}", json={"is_primary": True}, headers=h)
+    assert r.status_code == 200 and r.json()["is_primary"] is True
+
+    names = {n["surname"]: n["is_primary"] for n in (await client.get(base, headers=h)).json()}
+    assert names == {"Jones": True, "Smith": False}
+
+    # The person's display name now reflects the new primary.
+    person = (
+        await client.get(f"/api/v1/trees/{tid}/persons/{pid}", headers=h)
+    ).json()
+    assert person["primary_name"] == "Mary Jones"
+
+
+async def test_update_fields(client):
+    h, tid, pid = await _setup(client, "n-update@example.com")
+    base = f"/api/v1/trees/{tid}/persons/{pid}/names"
+    nid = (
+        await client.post(base, json={"name_type": "alias", "given": "Polly"}, headers=h)
+    ).json()["id"]
+    r = await client.patch(
+        f"{base}/{nid}", json={"surname": "Smith", "nickname": "Poll"}, headers=h
+    )
+    assert r.status_code == 200
+    assert r.json()["surname"] == "Smith" and r.json()["nickname"] == "Poll"
+
+
+async def test_delete_promotes_new_primary(client):
+    h, tid, pid = await _setup(client, "n-delete@example.com")
+    base = f"/api/v1/trees/{tid}/persons/{pid}/names"
+    alt = (
+        await client.post(
+            base, json={"name_type": "married", "given": "Mary", "surname": "Jones"}, headers=h
+        )
+    ).json()["id"]
+
+    # Delete the (primary) birth name; the married name should be promoted.
+    primary = next(
+        n for n in (await client.get(base, headers=h)).json() if n["is_primary"]
+    )
+    r = await client.delete(f"{base}/{primary['id']}", headers=h)
+    assert r.status_code == 204
+
+    names = (await client.get(base, headers=h)).json()
+    assert len(names) == 1 and names[0]["id"] == alt and names[0]["is_primary"] is True

backend/tests/test_recovery.py

@@ -41,7 +41,7 @@ async def test_person_delete_and_restore(client):
 
     assert (
         await client.delete(f"/api/v1/trees/{tree_id}/persons/{person_id}", headers=h)
-    ).status_code == 204
+    ).status_code == 200
     assert len((await client.get(f"/api/v1/trees/{tree_id}/persons", headers=h)).json()) == 0
     deleted = (
         await client.get(f"/api/v1/trees/{tree_id}/persons?deleted=true", headers=h)

backend/tests/test_relationship_dedup.py

@@ -0,0 +1,65 @@
+"""Duplicate relationships are rejected (no double-linking)."""
+
+from tests.conftest import auth, register
+
+
+async def _setup(client, email):
+    h = auth(await register(client, email))
+    tid = (await client.post("/api/v1/trees", json={"name": "T"}, headers=h)).json()["id"]
+
+    async def person(given):
+        return (
+            await client.post(f"/api/v1/trees/{tid}/persons", json={"given": given}, headers=h)
+        ).json()["id"]
+
+    return h, tid, person
+
+
+async def test_duplicate_parent_child_rejected(client):
+    h, tid, person = await _setup(client, "dup-pc@example.com")
+    karl = await person("Karl")
+    kid = await person("Kid")
+    body = {"type": "parent_child", "person_from_id": karl, "person_to_id": kid}
+
+    first = await client.post(f"/api/v1/trees/{tid}/relationships", json=body, headers=h)
+    assert first.status_code == 201
+    dup = await client.post(f"/api/v1/trees/{tid}/relationships", json=body, headers=h)
+    assert dup.status_code == 409
+
+
+async def test_duplicate_partnership_either_direction_rejected(client):
+    h, tid, person = await _setup(client, "dup-sp@example.com")
+    a = await person("A")
+    b = await person("B")
+
+    first = await client.post(
+        f"/api/v1/trees/{tid}/relationships",
+        json={"type": "partnership", "person_from_id": a, "person_to_id": b},
+        headers=h,
+    )
+    assert first.status_code == 201
+    # Same couple, reversed order — still a duplicate.
+    dup = await client.post(
+        f"/api/v1/trees/{tid}/relationships",
+        json={"type": "partnership", "person_from_id": b, "person_to_id": a},
+        headers=h,
+    )
+    assert dup.status_code == 409
+
+
+async def test_reverse_parent_child_is_allowed(client):
+    """A->B as parent_child shouldn't block B->A (different meaning)."""
+    h, tid, person = await _setup(client, "dup-rev@example.com")
+    a = await person("A")
+    b = await person("B")
+    r1 = await client.post(
+        f"/api/v1/trees/{tid}/relationships",
+        json={"type": "parent_child", "person_from_id": a, "person_to_id": b},
+        headers=h,
+    )
+    r2 = await client.post(
+        f"/api/v1/trees/{tid}/relationships",
+        json={"type": "parent_child", "person_from_id": b, "person_to_id": a},
+        headers=h,
+    )
+    assert r1.status_code == 201 and r2.status_code == 201

deploy/docker-compose.yml

@@ -40,12 +40,36 @@ services:
       retries: 10
     restart: unless-stopped
 
+  # One-shot schema migration: runs `alembic upgrade head` and exits. Backend
+  # and worker wait for it to finish, so on `docker compose up` the schema is
+  # always current before the app serves traffic — no manual migrate step.
+  # NOTE: a pure Watchtower image-swap recreates only the long-running
+  # containers, not this one-shot job, so Watchtower deploys should be paired
+  # with a `compose up` (see deploy docs) to re-run migrations.
+  migrate:
+    image: git.jpaul.io/justin/provenance-backend:${IMAGE_TAG:-test-main}
+    command: ["uv", "run", "--no-dev", "alembic", "upgrade", "head"]
+    labels:
+      com.centurylinklabs.watchtower.enable: "true"
+    environment:
+      APP_ENV: ${APP_ENV:-development}
+      DATABASE_URL: ${DATABASE_URL:-postgresql+asyncpg://provenance:provenance@postgres:5432/provenance}
+    depends_on:
+      postgres:
+        condition: service_healthy
+    restart: "no"
+
   backend:
     image: git.jpaul.io/justin/provenance-backend:${IMAGE_TAG:-test-main}
     labels:
       com.centurylinklabs.watchtower.enable: "true"
     environment:
       APP_ENV: ${APP_ENV:-development}
+      # Self-migrate on start so a Watchtower in-place image swap applies any new
+      # migrations (idempotent). The one-shot `migrate` service covers the same
+      # for `compose up`; the depends_on below serializes them so they never run
+      # alembic concurrently.
+      RUN_MIGRATIONS: "1"
       DATABASE_URL: ${DATABASE_URL:-postgresql+asyncpg://provenance:provenance@postgres:5432/provenance}
       S3_ENDPOINT_URL: ${S3_ENDPOINT_URL:-http://minio:9000}
       S3_BUCKET: ${S3_BUCKET:-provenance}
@@ -57,6 +81,8 @@ services:
         condition: service_healthy
       minio:
         condition: service_healthy
+      migrate:
+        condition: service_completed_successfully
     healthcheck:
       test:
         - CMD-SHELL
@@ -89,6 +115,8 @@ services:
         condition: service_healthy
       minio:
         condition: service_healthy
+      migrate:
+        condition: service_completed_successfully
     restart: unless-stopped
 
   frontend:

frontend/.gitignore

@@ -3,4 +3,5 @@
 /out
 /build
 next-env.d.ts
+*.tsbuildinfo
 .env*.local

frontend/app/globals.css

@@ -11,23 +11,28 @@
   --font-serif: var(--font-fraunces), Georgia, "Times New Roman", ui-serif, serif;
 }
 
-/* Adaptive tokens — ink/paper flip for light/dark; bronze + paper are constant. */
+/* Adaptive tokens — ink/paper flip for light/dark; bronze + paper are constant.
+   Theme is class-based (.dark on <html>) so it can be toggled manually; an inline
+   script in the root layout sets it pre-paint from the saved choice or the OS. */
 :root {
   --background: #f7f3ec;
   --foreground: #1a1a17;
   --muted: #6b6862;
   --surface: #fffdf9;
   --border: #e6ddcc;
+  /* Connector "lines between people" (pedigree + tree chart). Derived from Ink
+     (the brand mark color): a dark line on light, light on dark. */
+  --line: color-mix(in srgb, var(--foreground) 55%, transparent);
+  color-scheme: light;
 }
 
-@media (prefers-color-scheme: dark) {
+.dark {
-  :root {
+  --background: #161410;
-    --background: #161410;
+  --foreground: #f2eee6;
-    --foreground: #f2eee6;
+  --muted: #9a968e;
-    --muted: #9a968e;
+  --surface: #211d17;
-    --surface: #211d17;
+  --border: #353029;
-    --border: #353029;
+  color-scheme: dark;
-  }
 }
 
 body {
@@ -78,7 +83,7 @@ h3,
   left: -2.5rem;
   top: 50%;
   width: 2.5rem;
-  border-top: 1px solid var(--border);
+  border-top: 1px solid var(--line);
 }
 .ped-leaf {
   position: relative;
@@ -90,7 +95,7 @@ h3,
   left: 0;
   top: 50%;
   width: 1.5rem;
-  border-top: 1px solid var(--border);
+  border-top: 1px solid var(--line);
 }
 .ped-leaf::after {
   content: "";
@@ -98,7 +103,7 @@ h3,
   left: 0;
   top: 0;
   bottom: 0;
-  border-left: 1px solid var(--border);
+  border-left: 1px solid var(--line);
 }
 .ped-leaf:first-child::after {
   top: 50%;

frontend/app/import/layout.tsx

@@ -0,0 +1,5 @@
+import { AppShell } from "@/components/app-shell";
+
+export default function ImportLayout({ children }: { children: React.ReactNode }) {
+  return <AppShell>{children}</AppShell>;
+}

frontend/app/import/page.tsx

@@ -0,0 +1,15 @@
+import { GedcomImport } from "@/components/gedcom-import";
+
+export default function ImportPage() {
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-2xl font-semibold">Import</h1>
+        <p className="mt-1 text-sm text-[var(--muted)]">
+          Bring in a GEDCOM file — start a brand-new tree, or add to one you already have.
+        </p>
+      </div>
+      <GedcomImport />
+    </div>
+  );
+}

frontend/app/layout.tsx

@@ -18,9 +18,16 @@ export const metadata: Metadata = {
   icons: { icon: "/favicon.svg" },
 };
 
+// Sets the theme class before first paint to avoid a flash; reads the saved
+// choice ("light"/"dark"/"system") or falls back to the OS preference.
+const themeScript = `(function(){try{var t=localStorage.getItem("theme");var d=t==="dark"||((!t||t==="system")&&window.matchMedia("(prefers-color-scheme: dark)").matches);document.documentElement.classList.toggle("dark",d);}catch(e){}})();`;
+
 export default function RootLayout({ children }: { children: React.ReactNode }) {
   return (
-    <html lang="en" className={`${serif.variable} ${sans.variable}`}>
+    <html lang="en" className={`${serif.variable} ${sans.variable}`} suppressHydrationWarning>
+      <head>
+        <script dangerouslySetInnerHTML={{ __html: themeScript }} />
+      </head>
       <body className="min-h-screen antialiased">{children}</body>
     </html>
   );

frontend/app/settings/layout.tsx

@@ -0,0 +1,5 @@
+import { AppShell } from "@/components/app-shell";
+
+export default function SettingsLayout({ children }: { children: React.ReactNode }) {
+  return <AppShell>{children}</AppShell>;
+}

frontend/app/settings/page.tsx

@@ -0,0 +1,229 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { useRouter } from "next/navigation";
+
+import { api } from "@/lib/api/client";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+
+export default function SettingsPage() {
+  const router = useRouter();
+  const [me, setMe] = useState<{ display_name: string | null; email: string } | null>(null);
+
+  const [current, setCurrent] = useState("");
+  const [next, setNext] = useState("");
+  const [confirm, setConfirm] = useState("");
+  const [msg, setMsg] = useState<{ kind: "ok" | "err"; text: string } | null>(null);
+  const [busy, setBusy] = useState(false);
+
+  // Data export / restore / delete.
+  const [exporting, setExporting] = useState(false);
+  const [restoreMsg, setRestoreMsg] = useState<string | null>(null);
+  const [restoring, setRestoring] = useState(false);
+  const restoreRef = useRef<HTMLInputElement>(null);
+  const [deleteConfirm, setDeleteConfirm] = useState("");
+  const [deleting, setDeleting] = useState(false);
+
+  useEffect(() => {
+    api.GET("/api/v1/users/me").then((r) => setMe(r.data ?? null));
+  }, []);
+
+  async function exportData() {
+    setExporting(true);
+    const resp = await fetch("/api/v1/users/me/export", { credentials: "include" });
+    if (resp.ok) {
+      const blob = await resp.blob();
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "provenance-export.zip";
+      a.click();
+      URL.revokeObjectURL(url);
+    }
+    setExporting(false);
+  }
+
+  async function restoreData(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    if (restoreRef.current) restoreRef.current.value = "";
+    if (!file) return;
+    setRestoring(true);
+    setRestoreMsg(null);
+    const fd = new FormData();
+    fd.append("file", file);
+    const resp = await fetch("/api/v1/users/me/import", {
+      method: "POST",
+      body: fd,
+      credentials: "include",
+    });
+    setRestoring(false);
+    if (resp.ok) {
+      const c = await resp.json();
+      setRestoreMsg(`Restored ${c.trees} tree(s), ${c.persons} people into new trees.`);
+    } else {
+      setRestoreMsg("That doesn't look like a valid Provenance export.");
+    }
+  }
+
+  async function deleteAccount() {
+    if (deleteConfirm !== me?.email) return;
+    setDeleting(true);
+    const fd = new FormData();
+    fd.append("confirm_email", deleteConfirm);
+    const resp = await fetch("/api/v1/users/me", {
+      method: "DELETE",
+      body: fd,
+      credentials: "include",
+    });
+    setDeleting(false);
+    if (resp.ok) {
+      await api.POST("/api/v1/auth/logout");
+      router.push("/register");
+    }
+  }
+
+  async function changePassword(e: React.FormEvent) {
+    e.preventDefault();
+    setMsg(null);
+    if (next.length < 8) {
+      setMsg({ kind: "err", text: "New password must be at least 8 characters." });
+      return;
+    }
+    if (next !== confirm) {
+      setMsg({ kind: "err", text: "New passwords don't match." });
+      return;
+    }
+    setBusy(true);
+    const { error } = await api.POST("/api/v1/auth/change-password", {
+      body: { current_password: current, new_password: next },
+    });
+    setBusy(false);
+    if (error) {
+      setMsg({ kind: "err", text: "Current password is incorrect." });
+      return;
+    }
+    setCurrent("");
+    setNext("");
+    setConfirm("");
+    setMsg({ kind: "ok", text: "Password changed." });
+  }
+
+  return (
+    <div className="space-y-6">
+      <h1 className="text-2xl font-semibold">Settings</h1>
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Account</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-1 text-sm">
+          <div>
+            <span className="text-[var(--muted)]">Name: </span>
+            {me?.display_name ?? "—"}
+          </div>
+          <div>
+            <span className="text-[var(--muted)]">Email: </span>
+            {me?.email ?? "—"}
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Change password</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <form onSubmit={changePassword} className="flex max-w-sm flex-col gap-3">
+            <Input
+              type="password"
+              placeholder="Current password"
+              autoComplete="current-password"
+              value={current}
+              onChange={(e) => setCurrent(e.target.value)}
+            />
+            <Input
+              type="password"
+              placeholder="New password (min 8 chars)"
+              autoComplete="new-password"
+              value={next}
+              onChange={(e) => setNext(e.target.value)}
+            />
+            <Input
+              type="password"
+              placeholder="Confirm new password"
+              autoComplete="new-password"
+              value={confirm}
+              onChange={(e) => setConfirm(e.target.value)}
+            />
+            {msg && (
+              <p className={msg.kind === "ok" ? "text-sm text-bronze" : "text-sm text-red-600"}>
+                {msg.text}
+              </p>
+            )}
+            <Button type="submit" disabled={busy || !current || !next}>
+              {busy ? "Saving…" : "Change password"}
+            </Button>
+          </form>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Your data</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-5">
+          <div className="space-y-2">
+            <p className="text-sm text-[var(--muted)]">
+              Download a complete backup of every tree you own — people, sources, media, and
+              all — as a zip.
+            </p>
+            <Button variant="outline" onClick={exportData} disabled={exporting}>
+              {exporting ? "Preparing…" : "Export all my data"}
+            </Button>
+          </div>
+
+          <div className="space-y-2 border-t border-[var(--border)] pt-4">
+            <p className="text-sm text-[var(--muted)]">
+              Restore a backup. It’s imported into <strong>new</strong> trees — nothing existing
+              is touched or overwritten.
+            </p>
+            <input ref={restoreRef} type="file" accept=".zip" onChange={restoreData} className="hidden" />
+            <Button variant="outline" onClick={() => restoreRef.current?.click()} disabled={restoring}>
+              {restoring ? "Restoring…" : "Restore from backup"}
+            </Button>
+            {restoreMsg && <p className="text-sm text-bronze">{restoreMsg}</p>}
+          </div>
+        </CardContent>
+      </Card>
+
+      <Card className="border-red-300/60">
+        <CardHeader>
+          <CardTitle className="text-base text-red-700">Delete account</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          <p className="text-sm text-[var(--muted)]">
+            This deletes your account, the trees you own, and signs you out everywhere. Export
+            your data first if you might want it. Type <strong>{me?.email}</strong> to confirm.
+          </p>
+          <div className="flex max-w-sm flex-col gap-2">
+            <Input
+              placeholder="your email"
+              value={deleteConfirm}
+              onChange={(e) => setDeleteConfirm(e.target.value)}
+            />
+            <Button
+              variant="ghost"
+              className="bg-red-600 text-white hover:bg-red-700 hover:text-white"
+              onClick={deleteAccount}
+              disabled={deleting || deleteConfirm !== me?.email}
+            >
+              {deleting ? "Deleting…" : "Permanently delete my account"}
+            </Button>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

frontend/app/trees/[id]/cleanup/page.tsx

@@ -0,0 +1,393 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useParams } from "next/navigation";
+
+import { api } from "@/lib/api/client";
+import type { components } from "@/lib/api/schema";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+
+type Deceased = components["schemas"]["DeceasedCandidate"];
+type GenderProp = components["schemas"]["GenderProposal"];
+type NameIssue = components["schemas"]["NameIssue"];
+type Person = components["schemas"]["PersonRead"];
+
+const ISSUE_LABEL: Record<string, string> = {
+  date_in_surname: "date in surname",
+  date_in_given: "date in given name",
+  no_surname: "no surname",
+  packed_given: "long given name",
+};
+
+export default function CleanupPage() {
+  const params = useParams<{ id: string }>();
+  const treeId = params.id;
+
+  // 1) Deceased by birth year
+  const [year, setYear] = useState(1930);
+  const [deceased, setDeceased] = useState<Deceased[] | null>(null);
+  const [decSel, setDecSel] = useState<Set<string>>(new Set());
+  const [decMsg, setDecMsg] = useState<string | null>(null);
+
+  // 2) Gender from source GEDCOM
+  const [gender, setGender] = useState<GenderProp[] | null>(null);
+  const [genSel, setGenSel] = useState<Set<string>>(new Set());
+  const [genMsg, setGenMsg] = useState<string | null>(null);
+  const genFile = useRef<HTMLInputElement>(null);
+
+  // People still missing a sex (manual mop-up)
+  const [unset, setUnset] = useState<Person[] | null>(null);
+
+  // 3) Name issues
+  const [issues, setIssues] = useState<NameIssue[] | null>(null);
+  const [edits, setEdits] = useState<Record<string, { given: string; surname: string; on: boolean }>>({});
+  const [nameMsg, setNameMsg] = useState<string | null>(null);
+
+  async function previewDeceased() {
+    setDecMsg(null);
+    const { data } = await api.GET("/api/v1/trees/{tree_id}/cleanup/deceased", {
+      params: { path: { tree_id: treeId }, query: { born_on_or_before: year } },
+    });
+    setDeceased(data ?? []);
+    setDecSel(new Set((data ?? []).map((d) => d.person_id)));
+  }
+  async function applyDeceased() {
+    const ids = [...decSel];
+    const { data } = await api.POST("/api/v1/trees/{tree_id}/cleanup/deceased", {
+      params: { path: { tree_id: treeId } },
+      body: { person_ids: ids },
+    });
+    setDecMsg(`Marked ${data?.updated ?? 0} people deceased.`);
+    setDeceased(null);
+  }
+
+  async function previewGender(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    if (genFile.current) genFile.current.value = "";
+    if (!file) return;
+    setGenMsg(null);
+    const fd = new FormData();
+    fd.append("file", file);
+    const resp = await fetch(`/api/v1/trees/${treeId}/cleanup/gender/preview`, {
+      method: "POST",
+      body: fd,
+      credentials: "include",
+    });
+    if (resp.ok) {
+      const data: GenderProp[] = await resp.json();
+      setGender(data);
+      setGenSel(new Set(data.map((g) => g.person_id)));
+    }
+  }
+  const loadUnset = useCallback(async () => {
+    const { data } = await api.GET("/api/v1/trees/{tree_id}/persons", {
+      params: { path: { tree_id: treeId } },
+    });
+    setUnset(
+      (data ?? [])
+        .filter((p) => !p.gender)
+        .sort((a, b) => (a.primary_name ?? "").localeCompare(b.primary_name ?? "")),
+    );
+  }, [treeId]);
+
+  async function setSex(personId: string, gender: "male" | "female") {
+    await api.PATCH("/api/v1/trees/{tree_id}/persons/{person_id}", {
+      params: { path: { tree_id: treeId, person_id: personId } },
+      body: { gender },
+    });
+    setUnset((prev) => (prev ? prev.filter((p) => p.id !== personId) : prev));
+  }
+
+  async function guessGender() {
+    setGenMsg(null);
+    const { data } = await api.GET("/api/v1/trees/{tree_id}/cleanup/gender/guess", {
+      params: { path: { tree_id: treeId } },
+    });
+    setGender(data ?? []);
+    setGenSel(new Set((data ?? []).map((g) => g.person_id)));
+  }
+
+  async function applyGender() {
+    const updates = (gender ?? [])
+      .filter((g) => genSel.has(g.person_id))
+      .map((g) => ({ person_id: g.person_id, gender: g.proposed_gender }));
+    const { data } = await api.POST("/api/v1/trees/{tree_id}/cleanup/gender", {
+      params: { path: { tree_id: treeId } },
+      body: { updates },
+    });
+    setGenMsg(`Set gender on ${data?.updated ?? 0} people.`);
+    setGender(null);
+    loadUnset();
+  }
+
+  const loadNames = useCallback(async () => {
+    setNameMsg(null);
+    const { data } = await api.GET("/api/v1/trees/{tree_id}/cleanup/names", {
+      params: { path: { tree_id: treeId } },
+    });
+    setIssues(data ?? []);
+    const init: Record<string, { given: string; surname: string; on: boolean }> = {};
+    for (const i of data ?? []) {
+      init[i.name_id] = { given: i.given ?? "", surname: i.surname ?? "", on: false };
+    }
+    setEdits(init);
+  }, [treeId]);
+
+  useEffect(() => {
+    loadNames();
+    loadUnset();
+  }, [loadNames, loadUnset]);
+
+  async function applyNames() {
+    const chosen = (issues ?? []).filter((i) => edits[i.name_id]?.on);
+    const body = {
+      edits: chosen.map((i) => ({
+        name_id: i.name_id,
+        given: edits[i.name_id].given,
+        surname: edits[i.name_id].surname,
+      })),
+    };
+    if (!body.edits.length) return;
+    const { data } = await api.POST("/api/v1/trees/{tree_id}/cleanup/names", {
+      params: { path: { tree_id: treeId } },
+      body,
+    });
+    setNameMsg(`Fixed ${data?.updated ?? 0} names.`);
+    loadNames();
+  }
+
+  const toggle = (set: Set<string>, id: string, setter: (s: Set<string>) => void) => {
+    const n = new Set(set);
+    if (n.has(id)) n.delete(id);
+    else n.add(id);
+    setter(n);
+  };
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-2xl font-semibold">Cleanup</h1>
+        <p className="mt-1 text-sm text-[var(--muted)]">
+          Fix common import messes in bulk. Each tool previews its changes — nothing is saved
+          until you apply.
+        </p>
+      </div>
+
+      {/* 1) Deceased by year */}
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Mark deceased by birth year</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          <div className="flex flex-wrap items-end gap-2">
+            <label className="flex flex-col gap-1 text-sm">
+              <span className="text-xs text-[var(--muted)]">Born on or before</span>
+              <Input
+                type="number"
+                className="w-28"
+                value={year}
+                onChange={(e) => setYear(Number(e.target.value))}
+              />
+            </label>
+            <Button variant="outline" onClick={previewDeceased}>
+              Preview
+            </Button>
+          </div>
+          {decMsg && <p className="text-sm text-bronze">{decMsg}</p>}
+          {deceased && (
+            <div className="space-y-2">
+              <p className="text-sm text-[var(--muted)]">
+                {deceased.length} people born ≤ {year} (not already marked deceased).
+              </p>
+              <ul className="max-h-64 divide-y divide-[var(--border)] overflow-auto rounded-lg border border-[var(--border)]">
+                {deceased.map((d) => (
+                  <li key={d.person_id} className="flex items-center gap-3 px-3 py-1.5 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={decSel.has(d.person_id)}
+                      onChange={() => toggle(decSel, d.person_id, setDecSel)}
+                    />
+                    <span className="flex-1">{d.name}</span>
+                    <span className="text-xs text-[var(--muted)]">b. {d.birth_year}</span>
+                  </li>
+                ))}
+              </ul>
+              {deceased.length > 0 && (
+                <Button onClick={applyDeceased}>Mark {decSel.size} deceased</Button>
+              )}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* 2) Gender from source */}
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Set sex from a source GEDCOM</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          <p className="text-sm text-[var(--muted)]">
+            Upload your source <code>.ged</code> (it carries each person’s sex). We match by
+            name and propose sex only for people who don’t have it set.
+          </p>
+          <input
+            ref={genFile}
+            type="file"
+            accept=".ged,.gedcom,text/plain"
+            onChange={previewGender}
+            className="hidden"
+          />
+          <div className="flex flex-wrap gap-2">
+            <Button variant="outline" onClick={() => genFile.current?.click()}>
+              Choose source GEDCOM
+            </Button>
+            <Button variant="outline" onClick={guessGender}>
+              Guess from first name
+            </Button>
+          </div>
+          <p className="text-xs text-[var(--muted)]">
+            “Guess from first name” uses a built-in name dictionary for people with no sex set;
+            ambiguous names (Marion, Frances, …) are left for you to decide.
+          </p>
+          {genMsg && <p className="text-sm text-bronze">{genMsg}</p>}
+          {gender && (
+            <div className="space-y-2">
+              <p className="text-sm text-[var(--muted)]">{gender.length} matches with a sex to set.</p>
+              <ul className="max-h-64 divide-y divide-[var(--border)] overflow-auto rounded-lg border border-[var(--border)]">
+                {gender.map((g) => (
+                  <li key={g.person_id} className="flex items-center gap-3 px-3 py-1.5 text-sm">
+                    <input
+                      type="checkbox"
+                      checked={genSel.has(g.person_id)}
+                      onChange={() => toggle(genSel, g.person_id, setGenSel)}
+                    />
+                    <span className="flex-1">{g.name}</span>
+                    <span
+                      className="text-xs"
+                      style={{
+                        color:
+                          g.proposed_gender === "male"
+                            ? "rgb(120,159,172)"
+                            : "rgb(196,138,146)",
+                      }}
+                    >
+                      {g.proposed_gender}
+                    </span>
+                  </li>
+                ))}
+              </ul>
+              {gender.length > 0 && (
+                <Button onClick={applyGender}>Set sex on {genSel.size} people</Button>
+              )}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* People still missing a sex */}
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">
+            People with no sex set{unset ? ` (${unset.length})` : ""}
+          </CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          {unset === null ? (
+            <p className="text-sm text-[var(--muted)]">Loading…</p>
+          ) : unset.length === 0 ? (
+            <p className="text-sm text-[var(--muted)]">Everyone has a sex set. 🎉</p>
+          ) : (
+            <ul className="max-h-80 divide-y divide-[var(--border)] overflow-auto rounded-lg border border-[var(--border)]">
+              {unset.map((p) => (
+                <li key={p.id} className="flex items-center gap-3 px-3 py-1.5 text-sm">
+                  <a
+                    href={`/trees/${treeId}/persons/${p.id}`}
+                    className="flex-1 truncate hover:underline"
+                  >
+                    {p.primary_name ?? "Unnamed"}
+                  </a>
+                  <button
+                    onClick={() => setSex(p.id, "male")}
+                    className="rounded px-2 py-0.5 text-xs"
+                    style={{ color: "rgb(120,159,172)", border: "1px solid rgb(120,159,172)" }}
+                  >
+                    ♂ Male
+                  </button>
+                  <button
+                    onClick={() => setSex(p.id, "female")}
+                    className="rounded px-2 py-0.5 text-xs"
+                    style={{ color: "rgb(196,138,146)", border: "1px solid rgb(196,138,146)" }}
+                  >
+                    ♀ Female
+                  </button>
+                </li>
+              ))}
+            </ul>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* 3) Name issues */}
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Names that look broken</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-3">
+          {nameMsg && <p className="text-sm text-bronze">{nameMsg}</p>}
+          {issues === null ? (
+            <p className="text-sm text-[var(--muted)]">Scanning…</p>
+          ) : issues.length === 0 ? (
+            <p className="text-sm text-[var(--muted)]">No obvious name problems found.</p>
+          ) : (
+            <div className="space-y-2">
+              <p className="text-sm text-[var(--muted)]">
+                {issues.length} flagged. Edit given/surname, tick the ones to fix, then apply.
+              </p>
+              <ul className="space-y-2">
+                {issues.map((i) => {
+                  const e = edits[i.name_id] ?? { given: "", surname: "", on: false };
+                  return (
+                    <li key={i.name_id} className="flex flex-wrap items-center gap-2 text-sm">
+                      <input
+                        type="checkbox"
+                        checked={e.on}
+                        onChange={() =>
+                          setEdits((p) => ({ ...p, [i.name_id]: { ...e, on: !e.on } }))
+                        }
+                      />
+                      <Input
+                        className="h-9 w-40"
+                        placeholder="Given"
+                        value={e.given}
+                        onChange={(ev) =>
+                          setEdits((p) => ({ ...p, [i.name_id]: { ...e, given: ev.target.value } }))
+                        }
+                      />
+                      <Input
+                        className="h-9 w-40"
+                        placeholder="Surname"
+                        value={e.surname}
+                        onChange={(ev) =>
+                          setEdits((p) => ({
+                            ...p,
+                            [i.name_id]: { ...e, surname: ev.target.value },
+                          }))
+                        }
+                      />
+                      <span className="rounded bg-[var(--border)]/50 px-1.5 py-0.5 text-xs text-[var(--muted)]">
+                        {ISSUE_LABEL[i.issue] ?? i.issue}
+                      </span>
+                    </li>
+                  );
+                })}
+              </ul>
+              <Button onClick={applyNames}>Fix selected</Button>
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

frontend/app/trees/[id]/gedcom/page.tsx

@@ -1,65 +1,17 @@
 "use client";
 
-import Link from "next/link";
 import { useParams } from "next/navigation";
-import { useRef, useState } from "react";
 
-import { api } from "@/lib/api/client";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Input } from "@/components/ui/input";
+import { GedcomImport } from "@/components/gedcom-import";
 
-type Report = { counts: Record<string, number>; unmapped_tags: string[] };
+export default function TreeGedcomPage() {
-
-export default function GedcomPage() {
   const params = useParams<{ id: string }>();
   const treeId = params.id;
 
-  const [target, setTarget] = useState<"new" | "this">("new");
-  const [newName, setNewName] = useState("");
-  const [busy, setBusy] = useState(false);
-  const [report, setReport] = useState<Report | null>(null);
-  const [importedTreeId, setImportedTreeId] = useState<string | null>(null);
-  const fileRef = useRef<HTMLInputElement>(null);
-
-  async function onFile(e: React.ChangeEvent<HTMLInputElement>) {
-    const file = e.target.files?.[0];
-    if (!file) return;
-    setBusy(true);
-    setReport(null);
-    setImportedTreeId(null);
-
-    let tid = treeId;
-    if (target === "new") {
-      const { data } = await api.POST("/api/v1/trees", {
-        body: { name: newName.trim() || "Imported tree" },
-      });
-      if (!data) {
-        setBusy(false);
-        return;
-      }
-      tid = data.id;
-      setImportedTreeId(tid);
-    } else {
-      setImportedTreeId(treeId);
-    }
-
-    const fd = new FormData();
-    fd.append("file", file);
-    const resp = await fetch(`/api/v1/trees/${tid}/gedcom/import`, {
-      method: "POST",
-      body: fd,
-      credentials: "include",
-    });
-    if (resp.ok) setReport(await resp.json());
-    setBusy(false);
-    if (fileRef.current) fileRef.current.value = "";
-  }
-
   async function exportGed() {
-    const resp = await fetch(`/api/v1/trees/${treeId}/gedcom/export`, {
+    const resp = await fetch(`/api/v1/trees/${treeId}/gedcom/export`, { credentials: "include" });
-      credentials: "include",
-    });
     if (!resp.ok) return;
     const blob = await resp.blob();
     const url = URL.createObjectURL(blob);
@@ -74,76 +26,7 @@ export default function GedcomPage() {
     <div className="space-y-6">
       <h1 className="text-2xl font-semibold">Import &amp; export GEDCOM</h1>
 
-      <Card>
+      <GedcomImport fixedTreeId={treeId} />
-        <CardHeader>
-          <CardTitle className="text-base">Import a GEDCOM file</CardTitle>
-        </CardHeader>
-        <CardContent className="space-y-4">
-          <label className="flex items-center gap-2 text-sm">
-            <input
-              type="radio"
-              name="target"
-              checked={target === "new"}
-              onChange={() => setTarget("new")}
-            />
-            Import into a <strong>new tree</strong> (recommended)
-          </label>
-          {target === "new" && (
-            <Input
-              className="max-w-xs"
-              placeholder="New tree name"
-              value={newName}
-              onChange={(e) => setNewName(e.target.value)}
-            />
-          )}
-          <label className="flex items-center gap-2 text-sm">
-            <input
-              type="radio"
-              name="target"
-              checked={target === "this"}
-              onChange={() => setTarget("this")}
-            />
-            Import into <strong>this tree</strong> (appends)
-          </label>
-          {target === "this" && (
-            <p className="rounded-md bg-bronze/[0.08] px-3 py-2 text-sm text-[var(--muted)]">
-              Importing appends everyone in the file as new records — it does not merge with
-              people already in this tree, so duplicates are possible.
-            </p>
-          )}
-
-          <input ref={fileRef} type="file" accept=".ged,.gedcom,text/plain" onChange={onFile} className="hidden" />
-          <Button onClick={() => fileRef.current?.click()} disabled={busy}>
-            {busy ? "Importing…" : "Choose GEDCOM file"}
-          </Button>
-
-          {report && (
-            <div className="space-y-3 rounded-lg border border-[var(--border)] p-4">
-              <div className="font-medium">Import complete</div>
-              <div className="flex flex-wrap gap-x-6 gap-y-1 text-sm text-[var(--muted)]">
-                {Object.entries(report.counts).map(([k, v]) => (
-                  <span key={k}>
-                    <span className="font-medium text-[var(--foreground)]">{v}</span> {k}
-                  </span>
-                ))}
-              </div>
-              {report.unmapped_tags.length > 0 && (
-                <div className="text-xs text-[var(--muted)]">
-                  Unmapped tags (skipped): {report.unmapped_tags.join(", ")}
-                </div>
-              )}
-              {importedTreeId && (
-                <Link
-                  href={`/trees/${importedTreeId}`}
-                  className="inline-block text-sm text-bronze hover:underline"
-                >
-                  Open the imported tree →
-                </Link>
-              )}
-            </div>
-          )}
-        </CardContent>
-      </Card>
 
       <Card>
         <CardHeader>

frontend/app/trees/[id]/media/page.tsx

@@ -9,6 +9,9 @@ import { Button } from "@/components/ui/button";
 import { Card, CardContent } from "@/components/ui/card";
 
 type Media = components["schemas"]["MediaRead"];
+type Person = components["schemas"]["PersonRead"];
+
+const fieldCls = "h-8 w-full rounded-md border border-[var(--border)] bg-[var(--surface)] px-2 text-xs";
 
 function humanSize(bytes: number) {
   if (bytes < 1024) return `${bytes} B`;
@@ -22,6 +25,7 @@ export default function MediaPage() {
   const treeId = params.id;
 
   const [items, setItems] = useState<Media[]>([]);
+  const [people, setPeople] = useState<Person[]>([]);
   const [ready, setReady] = useState(false);
   const [uploading, setUploading] = useState(false);
   const fileRef = useRef<HTMLInputElement>(null);
@@ -34,10 +38,22 @@ export default function MediaPage() {
       router.push("/login");
       return;
     }
+    const ppl = await api.GET("/api/v1/trees/{tree_id}/persons", {
+      params: { path: { tree_id: treeId } },
+    });
     setItems(data ?? []);
+    setPeople(ppl.data ?? []);
     setReady(true);
   }, [router, treeId]);
 
+  async function linkPerson(mediaId: string, personId: string) {
+    await api.PATCH("/api/v1/trees/{tree_id}/media/{media_id}", {
+      params: { path: { tree_id: treeId, media_id: mediaId } },
+      body: { person_id: personId || null },
+    });
+    load();
+  }
+
   useEffect(() => {
     load();
   }, [load]);
@@ -124,6 +140,19 @@ export default function MediaPage() {
                     ×
                   </button>
                 </div>
+                <select
+                  className={`${fieldCls} mt-2`}
+                  value={m.person_id ?? ""}
+                  onChange={(e) => linkPerson(m.id, e.target.value)}
+                  title="Link to a person"
+                >
+                  <option value="">— link to person —</option>
+                  {people.map((p) => (
+                    <option key={p.id} value={p.id}>
+                      {p.primary_name ?? "Unnamed"}
+                    </option>
+                  ))}
+                </select>
               </CardContent>
             </Card>
           ))}

frontend/app/trees/[id]/page.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import Link from "next/link";
-import { useParams, useRouter } from "next/navigation";
+import { useParams, useRouter, useSearchParams } from "next/navigation";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 import { api } from "@/lib/api/client";
 import type { components } from "@/lib/api/schema";
@@ -26,7 +26,11 @@ type AddKind = "parent" | "child" | "partner";
 export default function FamilyViewPage() {
   const router = useRouter();
   const params = useParams<{ id: string }>();
+  const searchParams = useSearchParams();
   const treeId = params.id;
+  // ?focus=… lets another view (or a person page) hand us who to center on.
+  // Read once at mount so the focus→URL sync below doesn't trigger a refetch.
+  const initialFocus = useRef<string | null>(searchParams.get("focus"));
 
   const [people, setPeople] = useState<Person[]>([]);
   const [rels, setRels] = useState<Relationship[]>([]);
@@ -50,15 +54,21 @@ export default function FamilyViewPage() {
       router.push("/login");
       return;
     }
-    const [r, e] = await Promise.all([
+    const [r, e, t] = await Promise.all([
       api.GET("/api/v1/trees/{tree_id}/relationships", { params: { path: { tree_id: treeId } } }),
       api.GET("/api/v1/trees/{tree_id}/events", { params: { path: { tree_id: treeId } } }),
+      api.GET("/api/v1/trees/{tree_id}", { params: { path: { tree_id: treeId } } }),
     ]);
     const ppl = p.data ?? [];
+    const home = t.data?.home_person_id ?? null;
+    const homeId = home && ppl.some((x) => x.id === home) ? home : null;
+    const fromUrl = initialFocus.current && ppl.some((x) => x.id === initialFocus.current)
+      ? initialFocus.current
+      : null;
     setPeople(ppl);
     setRels(r.data ?? []);
     setEvents(e.data ?? []);
-    setFocusId((cur) => cur ?? ppl[0]?.id ?? null);
+    setFocusId((cur) => cur ?? fromUrl ?? homeId ?? ppl[0]?.id ?? null);
     setReady(true);
   }, [router, treeId]);
 
@@ -66,6 +76,16 @@ export default function FamilyViewPage() {
     load();
   }, [load]);
 
+  // Keep the focused person in the URL (?focus=…) so leaving and returning —
+  // e.g. opening a person then coming back — lands on the same person rather
+  // than resetting to the home person. `replace` keeps history clean.
+  useEffect(() => {
+    if (!focusId || searchParams.get("focus") === focusId) return;
+    const sp = new URLSearchParams(searchParams.toString());
+    sp.set("focus", focusId);
+    router.replace(`/trees/${treeId}?${sp.toString()}`, { scroll: false });
+  }, [focusId, searchParams, router, treeId]);
+
   // Debounced server-side fuzzy search (pg_trgm) across the whole tree.
   useEffect(() => {
     const q = search.trim();
@@ -83,8 +103,18 @@ export default function FamilyViewPage() {
   }, [search, treeId]);
 
   const byId = useMemo(() => new Map(people.map((p) => [p.id, p])), [people]);
+  // Order parents deterministically: father (male) on top, mother below, with a
+  // stable fallback when gender is unknown (so it doesn't depend on which link
+  // happened to be created first).
+  const parentRank = (id: string) => {
+    const g = byId.get(id)?.gender;
+    return g === "male" ? 0 : g === "female" ? 1 : 2;
+  };
   const parentsOf = (id: string) =>
-    rels.filter((r) => r.type === "parent_child" && r.person_to_id === id).map((r) => r.person_from_id);
+    rels
+      .filter((r) => r.type === "parent_child" && r.person_to_id === id)
+      .map((r) => r.person_from_id)
+      .sort((a, b) => parentRank(a) - parentRank(b));
   const childrenOf = (id: string) =>
     rels.filter((r) => r.type === "parent_child" && r.person_from_id === id).map((r) => r.person_to_id);
   const partnersOf = (id: string) =>
@@ -113,6 +143,12 @@ export default function FamilyViewPage() {
     return data?.id ?? null;
   }
 
+  // Create a new (blank) person and open their page to fill in details.
+  async function newPersonAndGo() {
+    const id = await addPerson("");
+    if (id) router.push(`/trees/${treeId}/persons/${id}`);
+  }
+
   async function createFirst(e: React.FormEvent) {
     e.preventDefault();
     if (!firstName.trim()) return;
@@ -317,6 +353,17 @@ export default function FamilyViewPage() {
   const partners = partnersOf(focus.id);
   const children = childrenOf(focus.id);
 
+  // "Dangling" people: not linked to anyone. Common after a GEDCOM import or a
+  // mistaken delete — surface them so they're not lost in the directory.
+  const connected = new Set<string>();
+  for (const r of rels) {
+    connected.add(r.person_from_id);
+    connected.add(r.person_to_id);
+  }
+  const unconnected = people
+    .filter((p) => !connected.has(p.id))
+    .sort((a, b) => (a.primary_name ?? "").localeCompare(b.primary_name ?? ""));
+
   const sorted = [...people].sort((a, b) =>
     (a.primary_name ?? "").localeCompare(b.primary_name ?? ""),
   );
@@ -328,12 +375,17 @@ export default function FamilyViewPage() {
     <div className="space-y-8">
       <div className="flex flex-wrap items-center justify-between gap-3">
         <h1 className="text-2xl font-semibold">Family view</h1>
-        <Link
+        <div className="flex items-center gap-3">
-          href={`/trees/${treeId}/persons/${focus.id}`}
+          <Button size="sm" onClick={newPersonAndGo}>
-          className="text-sm text-bronze hover:underline"
+            + Add person
-        >
+          </Button>
-          Open {focus.primary_name ?? "person"} →
+          <Link
-        </Link>
+            href={`/trees/${treeId}/persons/${focus.id}?from=people`}
+            className="text-sm text-bronze hover:underline"
+          >
+            Open {focus.primary_name ?? "person"} →
+          </Link>
+        </div>
       </div>
 
       {/* Pedigree: focus → parents → grandparents, with bracket connectors */}
@@ -380,6 +432,40 @@ export default function FamilyViewPage() {
         </Card>
       </div>
 
+      {/* Unconnected people — not linked to anyone in the tree */}
+      {unconnected.length > 0 && (
+        <Card className="border-bronze/40">
+          <CardContent className="space-y-3 p-6">
+            <div className="flex items-center justify-between">
+              <h2 className="font-serif text-base font-semibold">
+                Not connected to anyone ({unconnected.length})
+              </h2>
+              <span className="text-xs text-[var(--muted)]">
+                Open one and add a relationship, or delete it.
+              </span>
+            </div>
+            <div className="flex flex-wrap gap-3">
+              {unconnected.slice(0, 60).map((p) => (
+                <div key={p.id} className="flex items-center gap-1">
+                  <PersonBox id={p.id} muted />
+                  <Link
+                    href={`/trees/${treeId}/persons/${p.id}?from=people`}
+                    className="text-xs text-bronze hover:underline"
+                  >
+                    open
+                  </Link>
+                </div>
+              ))}
+            </div>
+            {unconnected.length > 60 && (
+              <p className="text-xs text-[var(--muted)]">
+                Showing 60 of {unconnected.length}.
+              </p>
+            )}
+          </CardContent>
+        </Card>
+      )}
+
       {/* Scrollable, searchable people directory (scales to large trees) */}
       <div className="space-y-3">
         <div className="flex flex-wrap items-center justify-between gap-3">

frontend/app/trees/[id]/persons/[personId]/page.tsx

@@ -1,16 +1,19 @@
 "use client";
 
 import Link from "next/link";
-import { useParams, useRouter } from "next/navigation";
+import { useParams, useRouter, useSearchParams } from "next/navigation";
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 import { api } from "@/lib/api/client";
 import type { components } from "@/lib/api/schema";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Input } from "@/components/ui/input";
+import { PersonCombobox } from "@/components/person-combobox";
 
 type Person = components["schemas"]["PersonRead"];
+type Name = components["schemas"]["NameRead"];
+type Me = components["schemas"]["UserRead"];
 type Event = components["schemas"]["EventRead"];
 type Relationship = components["schemas"]["RelationshipRead"];
 type Qualifier = components["schemas"]["ParentChildQualifier"];
@@ -22,12 +25,30 @@ type CitationCreate = components["schemas"]["CitationCreate"];
 const fieldCls = "h-9 rounded-md border border-[var(--border)] bg-[var(--surface)] px-2 text-sm";
 const QUALIFIERS: Qualifier[] = ["biological", "adoptive", "step", "foster", "donor", "guardian"];
 
+// Typed name vocabulary. "birth" is the maiden/birth name; "married" etc. are
+// alternates. The maiden name stays primary by convention (Ancestry/FamilySearch).
+const NAME_TYPES: { value: string; label: string }[] = [
+  { value: "birth", label: "Birth / maiden" },
+  { value: "married", label: "Married" },
+  { value: "alias", label: "Also known as" },
+  { value: "nickname", label: "Nickname" },
+  { value: "religious", label: "Religious" },
+  { value: "immigration", label: "Anglicized" },
+];
+const nameTypeLabel = (t: string) =>
+  NAME_TYPES.find((n) => n.value === t)?.label ?? t;
+const formatName = (n: Name) =>
+  [n.given, n.surname].filter(Boolean).join(" ") || "—";
+
 // Curated genealogical event vocabulary (with an escape hatch).
 const EVENT_TYPES = [
   "birth", "death", "marriage", "divorce", "engagement", "baptism", "burial",
   "residence", "census", "immigration", "emigration", "occupation", "education",
   "military service", "naturalization", "other",
 ];
+// These belong to a couple, not a person — they attach to the partnership and
+// show on both partners' pages, so they're only entered once.
+const PARTNERSHIP_EVENTS = ["marriage", "divorce", "engagement"];
 const MONTHS = ["", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
 const GED_MON = ["", "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"];
 const DATE_QUALS: Record<string, string> = { exact: "", about: "ABT", before: "BEF", after: "AFT" };
@@ -83,19 +104,38 @@ function parseDateValue(v: string | null | undefined) {
 export default function PersonDetailPage() {
   const router = useRouter();
   const params = useParams<{ id: string; personId: string }>();
+  const searchParams = useSearchParams();
   const treeId = params.id;
   const personId = params.personId;
+  // Where we were opened from, so "back" returns there (centered on this
+  // person) instead of always dumping onto the People view's home person.
+  const from = searchParams.get("from") === "people" ? "people" : "tree";
+  const backHref =
+    from === "people"
+      ? `/trees/${treeId}?focus=${personId}`
+      : `/trees/${treeId}/tree?focus=${personId}`;
+  const backLabel = from === "people" ? "← Back to People" : "← Back to Tree";
+  // Carry the origin through person→person links so the chain keeps its anchor.
+  const personHref = (id: string) => `/trees/${treeId}/persons/${id}?from=${from}`;
 
   const [person, setPerson] = useState<Person | null>(null);
   const [people, setPeople] = useState<Person[]>([]);
+  const [names, setNames] = useState<Name[]>([]);
+  const [me, setMe] = useState<Me | null>(null);
+  const [tree, setTree] = useState<components["schemas"]["TreeRead"] | null>(null);
   const [events, setEvents] = useState<Event[]>([]);
   const [rels, setRels] = useState<Relationship[]>([]);
   const [sources, setSources] = useState<Source[]>([]);
   const [citations, setCitations] = useState<Citation[]>([]);
+  const [media, setMedia] = useState<components["schemas"]["MediaRead"][]>([]);
+  const [uploadingMedia, setUploadingMedia] = useState(false);
+  const mediaFileRef = useRef<HTMLInputElement>(null);
   const [ready, setReady] = useState(false);
 
   const [evType, setEvType] = useState("birth");
   const [evTypeOther, setEvTypeOther] = useState("");
+  const [evSpouse, setEvSpouse] = useState(""); // partner for a partnership event
+  const [allEvents, setAllEvents] = useState<Event[]>([]); // tree-wide, for partnership events
   const [dateQual, setDateQual] = useState("exact");
   const [dateDay, setDateDay] = useState("");
   const [dateMonth, setDateMonth] = useState("");
@@ -121,6 +161,19 @@ export default function PersonDetailPage() {
   const [relKind, setRelKind] = useState<"parent" | "child" | "partner" | "sibling">("parent");
   const [relOther, setRelOther] = useState("");
   const [relQual, setRelQual] = useState<Qualifier>("biological");
+  const [relErr, setRelErr] = useState<string | null>(null);
+
+  // Add-name form + inline edit.
+  const [nameType, setNameType] = useState("married");
+  const [nGiven, setNGiven] = useState("");
+  const [nSurname, setNSurname] = useState("");
+  const [editNameId, setEditNameId] = useState<string | null>(null);
+  const [enType, setEnType] = useState("married");
+  const [enGiven, setEnGiven] = useState("");
+  const [enSurname, setEnSurname] = useState("");
+
+  // Delete confirmation (with optional cascade to descendants).
+  const [confirmingDelete, setConfirmingDelete] = useState(false);
 
   // Inline citation form: which fact is being cited ("p" = person, `e:<id>`).
   const [citeFor, setCiteFor] = useState<string | null>(null);
@@ -136,8 +189,13 @@ export default function PersonDetailPage() {
       return;
     }
     setPerson(p.data ?? null);
-    const [all, ev, rl, src, cit] = await Promise.all([
+    const [all, nm, mine, tr, ev, rl, src, cit, evAll, med] = await Promise.all([
       api.GET("/api/v1/trees/{tree_id}/persons", { params: { path: { tree_id: treeId } } }),
+      api.GET("/api/v1/trees/{tree_id}/persons/{person_id}/names", {
+        params: { path: { tree_id: treeId, person_id: personId } },
+      }),
+      api.GET("/api/v1/users/me"),
+      api.GET("/api/v1/trees/{tree_id}", { params: { path: { tree_id: treeId } } }),
       api.GET("/api/v1/trees/{tree_id}/persons/{person_id}/events", {
         params: { path: { tree_id: treeId, person_id: personId } },
       }),
@@ -146,9 +204,16 @@ export default function PersonDetailPage() {
       }),
       api.GET("/api/v1/trees/{tree_id}/sources", { params: { path: { tree_id: treeId } } }),
       api.GET("/api/v1/trees/{tree_id}/citations", { params: { path: { tree_id: treeId } } }),
+      api.GET("/api/v1/trees/{tree_id}/events", { params: { path: { tree_id: treeId } } }),
+      api.GET("/api/v1/trees/{tree_id}/media", { params: { path: { tree_id: treeId } } }),
     ]);
     setPeople(all.data ?? []);
+    setNames(nm.data ?? []);
+    setMe(mine.data ?? null);
+    setTree(tr.data ?? null);
     setEvents(ev.data ?? []);
+    setAllEvents(evAll.data ?? []);
+    setMedia(med.data ?? []);
     setRels(rl.data ?? []);
     setSources(src.data ?? []);
     setCitations(cit.data ?? []);
@@ -176,6 +241,23 @@ export default function PersonDetailPage() {
   const eventCites = (id: string) => citations.filter((c) => c.event_id === id);
   const personCites = citations.filter((c) => c.person_id === personId);
 
+  // Partnership events live on the relationship and show on both partners.
+  const myPartnerRels = rels.filter(
+    (r) => r.type === "partnership" && (r.person_from_id === personId || r.person_to_id === personId),
+  );
+  const myPartnerRelIds = new Set(myPartnerRels.map((r) => r.id));
+  const relEvents = allEvents.filter(
+    (e) => e.relationship_id && myPartnerRelIds.has(e.relationship_id),
+  );
+  const spouseOfRelEvent = (relId: string | null | undefined) => {
+    const r = myPartnerRels.find((x) => x.id === relId);
+    if (!r) return null;
+    return r.person_from_id === personId ? r.person_to_id : r.person_from_id;
+  };
+  const isPartnershipType = (t: string) => PARTNERSHIP_EVENTS.includes(t);
+  // Personal events + this person's partnership events, shown together.
+  const shownEvents = [...events, ...relEvents];
+
   async function addEvent(e: React.FormEvent) {
     e.preventDefault();
     const event_type = evType === "other" ? evTypeOther.trim() : evType;
@@ -186,9 +268,47 @@ export default function PersonDetailPage() {
       dateMonth,
       dateYear,
     );
+
+    let body: components["schemas"]["EventCreate"] = {
+      event_type,
+      person_id: personId,
+      date_value,
+      date_start,
+      date_precision,
+    };
+
+    // A partnership event belongs to the couple: attach it to the partnership
+    // relationship (creating it if needed) so it's entered once and shows on
+    // both partners.
+    if (isPartnershipType(event_type)) {
+      if (!evSpouse) return;
+      let relId = myPartnerRels.find(
+        (r) => r.person_from_id === evSpouse || r.person_to_id === evSpouse,
+      )?.id;
+      if (!relId) {
+        const { data, error: relErr } = await api.POST(
+          "/api/v1/trees/{tree_id}/relationships",
+          {
+            params: { path: { tree_id: treeId } },
+            body: { type: "partnership", person_from_id: personId, person_to_id: evSpouse },
+          },
+        );
+        if (relErr || !data) return;
+        relId = data.id;
+      }
+      body = {
+        event_type,
+        relationship_id: relId,
+        person_id: null,
+        date_value,
+        date_start,
+        date_precision,
+      };
+    }
+
     const { error } = await api.POST("/api/v1/trees/{tree_id}/events", {
       params: { path: { tree_id: treeId } },
-      body: { event_type, person_id: personId, date_value, date_start, date_precision },
+      body,
     });
     if (!error) {
       setDateDay("");
@@ -196,6 +316,7 @@ export default function PersonDetailPage() {
       setDateYear("");
       setDateQual("exact");
       setEvTypeOther("");
+      setEvSpouse("");
       load();
     }
   }
@@ -233,28 +354,50 @@ export default function PersonDetailPage() {
     }
   }
 
-  async function addRel(e: React.FormEvent) {
+  async function linkRelative(otherId: string): Promise<boolean> {
-    e.preventDefault();
-    if (!relOther) return;
     let body: RelCreate;
     if (relKind === "parent") {
-      body = { type: "parent_child", person_from_id: relOther, person_to_id: personId, qualifier: relQual };
+      body = { type: "parent_child", person_from_id: otherId, person_to_id: personId, qualifier: relQual };
     } else if (relKind === "child") {
-      body = { type: "parent_child", person_from_id: personId, person_to_id: relOther, qualifier: relQual };
+      body = { type: "parent_child", person_from_id: personId, person_to_id: otherId, qualifier: relQual };
     } else if (relKind === "partner") {
-      body = { type: "partnership", person_from_id: personId, person_to_id: relOther };
+      body = { type: "partnership", person_from_id: personId, person_to_id: otherId };
     } else {
-      body = { type: "sibling", person_from_id: personId, person_to_id: relOther };
+      body = { type: "sibling", person_from_id: personId, person_to_id: otherId };
     }
     const { error } = await api.POST("/api/v1/trees/{tree_id}/relationships", {
       params: { path: { tree_id: treeId } },
       body,
     });
-    if (!error) {
+    return !error;
+  }
+
+  async function addRel(e: React.FormEvent) {
+    e.preventDefault();
+    if (!relOther) return;
+    setRelErr(null);
+    if (await linkRelative(relOther)) {
       setRelOther("");
       load();
+    } else {
+      setRelErr("They're already linked that way.");
     }
   }
+
+  // Create a brand-new person, link them in the chosen role, then jump to their
+  // page so the user can fill in details immediately.
+  async function createRelativeAndGo(name: string) {
+    const toks = name.trim().split(/\s+/).filter(Boolean);
+    const given = toks.length > 1 ? toks.slice(0, -1).join(" ") : toks[0] ?? name.trim();
+    const surname = toks.length > 1 ? toks[toks.length - 1] : null;
+    const { data } = await api.POST("/api/v1/trees/{tree_id}/persons", {
+      params: { path: { tree_id: treeId } },
+      body: { given, surname },
+    });
+    if (!data) return;
+    await linkRelative(data.id);
+    router.push(personHref(data.id));
+  }
   async function removeRel(id: string) {
     await api.DELETE("/api/v1/trees/{tree_id}/relationships/{relationship_id}", {
       params: { path: { tree_id: treeId, relationship_id: id } },
@@ -283,13 +426,105 @@ export default function PersonDetailPage() {
     load();
   }
 
-  async function removePerson() {
+  async function removePerson(cascade: boolean) {
     await api.DELETE("/api/v1/trees/{tree_id}/persons/{person_id}", {
-      params: { path: { tree_id: treeId, person_id: personId } },
+      params: { path: { tree_id: treeId, person_id: personId }, query: { cascade } },
     });
     router.push(`/trees/${treeId}`);
   }
 
+  async function addName(e: React.FormEvent) {
+    e.preventDefault();
+    if (!nGiven.trim() && !nSurname.trim()) return;
+    const { error } = await api.POST("/api/v1/trees/{tree_id}/persons/{person_id}/names", {
+      params: { path: { tree_id: treeId, person_id: personId } },
+      body: { name_type: nameType, given: nGiven || null, surname: nSurname || null },
+    });
+    if (!error) {
+      setNGiven("");
+      setNSurname("");
+      setNameType("married");
+      load();
+    }
+  }
+
+  function startEditName(n: Name) {
+    setEditNameId(n.id);
+    setEnType(n.name_type);
+    setEnGiven(n.given ?? "");
+    setEnSurname(n.surname ?? "");
+  }
+
+  async function saveName() {
+    if (!editNameId) return;
+    const { error } = await api.PATCH(
+      "/api/v1/trees/{tree_id}/persons/{person_id}/names/{name_id}",
+      {
+        params: { path: { tree_id: treeId, person_id: personId, name_id: editNameId } },
+        body: { name_type: enType, given: enGiven || null, surname: enSurname || null },
+      },
+    );
+    if (!error) {
+      setEditNameId(null);
+      load();
+    }
+  }
+
+  async function makePrimaryName(id: string) {
+    await api.PATCH("/api/v1/trees/{tree_id}/persons/{person_id}/names/{name_id}", {
+      params: { path: { tree_id: treeId, person_id: personId, name_id: id } },
+      body: { is_primary: true },
+    });
+    load();
+  }
+
+  async function removeName(id: string) {
+    await api.DELETE("/api/v1/trees/{tree_id}/persons/{person_id}/names/{name_id}", {
+      params: { path: { tree_id: treeId, person_id: personId, name_id: id } },
+    });
+    load();
+  }
+
+  async function setSelf(link: boolean) {
+    await api.PATCH("/api/v1/users/me/self-person", {
+      body: { self_person_id: link ? personId : null },
+    });
+    load();
+  }
+
+  async function setDefaultPerson(make: boolean) {
+    await api.PATCH("/api/v1/trees/{tree_id}", {
+      params: { path: { tree_id: treeId } },
+      body: { home_person_id: make ? personId : null },
+    });
+    load();
+  }
+
+  async function uploadMediaForPerson(e: React.ChangeEvent<HTMLInputElement>) {
+    const file = e.target.files?.[0];
+    if (mediaFileRef.current) mediaFileRef.current.value = "";
+    if (!file) return;
+    setUploadingMedia(true);
+    const fd = new FormData();
+    fd.append("file", file);
+    fd.append("person_id", personId); // link on upload
+    await fetch(`/api/v1/trees/${treeId}/media`, {
+      method: "POST",
+      body: fd,
+      credentials: "include",
+    });
+    setUploadingMedia(false);
+    load();
+  }
+
+  async function linkMedia(mediaId: string, link: boolean) {
+    await api.PATCH("/api/v1/trees/{tree_id}/media/{media_id}", {
+      params: { path: { tree_id: treeId, media_id: mediaId } },
+      body: { person_id: link ? personId : null },
+    });
+    load();
+  }
+
   function startEditPerson(current: Person) {
     const t = (current.primary_name ?? "").trim().split(/\s+/).filter(Boolean);
     setPGiven(t.length > 1 ? t.slice(0, -1).join(" ") : (t[0] ?? ""));
@@ -320,6 +555,9 @@ export default function PersonDetailPage() {
   if (!ready) return <p className="text-[var(--muted)]">Loading…</p>;
   if (!person) return <p className="text-[var(--muted)]">Not found.</p>;
 
+  const isSelf = me?.self_person_id === personId;
+  const isDefault = tree?.home_person_id === personId;
+
   // Inline "cite" control: a badge with count, a toggle, and the picker form.
   function citeControl(key: string, target: Partial<CitationCreate>, cites: Citation[]) {
     return (
@@ -397,7 +635,7 @@ export default function PersonDetailPage() {
         <ul className="mt-1 space-y-1">
           {items.map((r) => (
             <li key={r.id} className="flex items-center justify-between text-sm">
-              <Link href={`/trees/${treeId}/persons/${otherId(r)}`} className="hover:underline">
+              <Link href={personHref(otherId(r))} className="hover:underline">
                 {nameOf(otherId(r))}
                 {r.qualifier ? <span className="text-[var(--muted)]"> · {r.qualifier}</span> : null}
               </Link>
@@ -416,9 +654,17 @@ export default function PersonDetailPage() {
 
   return (
     <div className="space-y-6">
-      <Link href={`/trees/${treeId}`} className="text-sm text-[var(--muted)] hover:underline">
+      <div className="flex items-center justify-between gap-3">
-        ← Back to tree
+        <Link href={backHref} className="text-sm text-[var(--muted)] hover:underline">
-      </Link>
+          {backLabel}
+        </Link>
+        <Link
+          href={`/trees/${treeId}/tree?focus=${personId}`}
+          className="text-sm text-bronze hover:underline"
+        >
+          View in tree →
+        </Link>
+      </div>
 
       {editingPerson ? (
         <form
@@ -431,7 +677,11 @@ export default function PersonDetailPage() {
           <div className="flex flex-wrap gap-2">
             <Input className="w-40" placeholder="Given name" value={pGiven} onChange={(e) => setPGiven(e.target.value)} />
             <Input className="w-40" placeholder="Surname" value={pSurname} onChange={(e) => setPSurname(e.target.value)} />
-            <Input className="w-32" placeholder="Gender" value={pGender} onChange={(e) => setPGender(e.target.value)} />
+            <select className={fieldCls} value={pGender} onChange={(e) => setPGender(e.target.value)}>
+              <option value="">Gender: —</option>
+              <option value="male">Male</option>
+              <option value="female">Female</option>
+            </select>
             <select className={fieldCls} value={pLiving} onChange={(e) => setPLiving(e.target.value)}>
               <option value="unknown">Status: unknown</option>
               <option value="living">Living</option>
@@ -458,29 +708,227 @@ export default function PersonDetailPage() {
         </form>
       ) : (
         <div className="flex flex-wrap items-center justify-between gap-2">
-          <h1 className="text-3xl font-semibold">{person.primary_name ?? "Unnamed person"}</h1>
+          <h1 className="flex flex-wrap items-center gap-3 text-3xl font-semibold">
-          <div className="flex items-center gap-3">
+            <span className="inline-flex items-center gap-2">
+              {person.primary_name ?? "Unnamed person"}
+              {person.gender === "male" && (
+                <span title="Male" aria-label="Male" style={{ color: "rgb(120, 159, 172)" }}>
+                  ♂
+                </span>
+              )}
+              {person.gender === "female" && (
+                <span title="Female" aria-label="Female" style={{ color: "rgb(196, 138, 146)" }}>
+                  ♀
+                </span>
+              )}
+            </span>
+            {isSelf && (
+              <span className="rounded-full bg-bronze/15 px-2.5 py-1 text-xs font-medium text-bronze">
+                This is you
+              </span>
+            )}
+            {isDefault && (
+              <span className="rounded-full border border-bronze/40 px-2.5 py-1 text-xs font-medium text-bronze">
+                Default person
+              </span>
+            )}
+          </h1>
+          <div className="flex flex-wrap items-center gap-3">
             {citeControl("p", { person_id: personId }, personCites)}
+            {isSelf ? (
+              <Button variant="ghost" size="sm" onClick={() => setSelf(false)}>
+                Unlink me
+              </Button>
+            ) : (
+              <Button variant="outline" size="sm" onClick={() => setSelf(true)}>
+                This is me
+              </Button>
+            )}
+            {!isDefault && (
+              <Button variant="outline" size="sm" onClick={() => setDefaultPerson(true)}>
+                Set as default
+              </Button>
+            )}
             <Button variant="outline" size="sm" onClick={() => startEditPerson(person)}>
               Edit
             </Button>
-            <Button variant="ghost" size="sm" onClick={removePerson}>
+            <Button variant="ghost" size="sm" onClick={() => setConfirmingDelete(true)}>
               Delete
             </Button>
           </div>
         </div>
       )}
 
+      {confirmingDelete && (
+        <div className="space-y-3 rounded-lg border border-bronze/40 bg-bronze/[0.05] p-4">
+          <p className="text-sm">
+            Delete <strong>{person.primary_name ?? "this person"}</strong>? Their relationships
+            will be removed too. This can be undone from Recovery.
+          </p>
+          <div className="flex flex-wrap gap-2">
+            <Button variant="ghost" size="sm" onClick={() => removePerson(false)}>
+              Delete only this person
+            </Button>
+            <Button variant="outline" size="sm" onClick={() => removePerson(true)}>
+              Delete with all descendants
+            </Button>
+            <button
+              type="button"
+              onClick={() => setConfirmingDelete(false)}
+              className="text-xs text-[var(--muted)]"
+            >
+              cancel
+            </button>
+          </div>
+        </div>
+      )}
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Names</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          {names.length === 0 ? (
+            <p className="text-sm text-[var(--muted)]">No names yet.</p>
+          ) : (
+            <ul className="space-y-2">
+              {names.map((n) =>
+                editNameId === n.id ? (
+                  <li key={n.id}>
+                    <form
+                      onSubmit={(e) => {
+                        e.preventDefault();
+                        saveName();
+                      }}
+                      className="flex flex-wrap items-center gap-2"
+                    >
+                      <select
+                        className={fieldCls}
+                        value={enType}
+                        onChange={(e) => setEnType(e.target.value)}
+                      >
+                        {NAME_TYPES.map((t) => (
+                          <option key={t.value} value={t.value}>
+                            {t.label}
+                          </option>
+                        ))}
+                      </select>
+                      <Input
+                        className="h-9 w-36"
+                        placeholder="Given"
+                        value={enGiven}
+                        onChange={(e) => setEnGiven(e.target.value)}
+                      />
+                      <Input
+                        className="h-9 w-36"
+                        placeholder="Surname"
+                        value={enSurname}
+                        onChange={(e) => setEnSurname(e.target.value)}
+                      />
+                      <Button type="submit" size="sm">
+                        Save
+                      </Button>
+                      <button
+                        type="button"
+                        onClick={() => setEditNameId(null)}
+                        className="text-xs text-[var(--muted)]"
+                      >
+                        cancel
+                      </button>
+                    </form>
+                  </li>
+                ) : (
+                  <li
+                    key={n.id}
+                    className="flex flex-wrap items-center justify-between gap-2 text-sm"
+                  >
+                    <span className="flex items-center gap-2">
+                      <span className="font-medium">{formatName(n)}</span>
+                      <span className="rounded bg-[var(--border)]/50 px-1.5 py-0.5 text-xs text-[var(--muted)]">
+                        {nameTypeLabel(n.name_type)}
+                      </span>
+                      {n.is_primary && (
+                        <span className="rounded bg-bronze/15 px-1.5 py-0.5 text-xs text-bronze">
+                          primary
+                        </span>
+                      )}
+                    </span>
+                    <span className="flex items-center gap-3">
+                      {!n.is_primary && (
+                        <button
+                          onClick={() => makePrimaryName(n.id)}
+                          className="text-xs text-bronze hover:underline"
+                        >
+                          make primary
+                        </button>
+                      )}
+                      <button
+                        onClick={() => startEditName(n)}
+                        className="text-xs text-bronze hover:underline"
+                      >
+                        edit
+                      </button>
+                      <button
+                        onClick={() => removeName(n.id)}
+                        className="text-[var(--muted)] hover:text-bronze"
+                        aria-label="Remove"
+                      >
+                        ×
+                      </button>
+                    </span>
+                  </li>
+                ),
+              )}
+            </ul>
+          )}
+          <form onSubmit={addName} className="flex flex-wrap items-end gap-2">
+            <label className="flex flex-col gap-1">
+              <span className="text-xs text-[var(--muted)]">Type</span>
+              <select
+                className={fieldCls}
+                value={nameType}
+                onChange={(e) => setNameType(e.target.value)}
+              >
+                {NAME_TYPES.map((t) => (
+                  <option key={t.value} value={t.value}>
+                    {t.label}
+                  </option>
+                ))}
+              </select>
+            </label>
+            <label className="flex flex-col gap-1">
+              <span className="text-xs text-[var(--muted)]">Given</span>
+              <Input
+                className="h-9 w-36"
+                placeholder="Given"
+                value={nGiven}
+                onChange={(e) => setNGiven(e.target.value)}
+              />
+            </label>
+            <label className="flex flex-col gap-1">
+              <span className="text-xs text-[var(--muted)]">Surname</span>
+              <Input
+                className="h-9 w-36"
+                placeholder="Surname"
+                value={nSurname}
+                onChange={(e) => setNSurname(e.target.value)}
+              />
+            </label>
+            <Button type="submit">Add name</Button>
+          </form>
+        </CardContent>
+      </Card>
+
       <Card>
         <CardHeader>
           <CardTitle className="text-base">Life events</CardTitle>
         </CardHeader>
         <CardContent className="space-y-4">
-          {events.length === 0 ? (
+          {shownEvents.length === 0 ? (
             <p className="text-sm text-[var(--muted)]">No events yet.</p>
           ) : (
             <ul className="space-y-2">
-              {events.map((ev) =>
+              {shownEvents.map((ev) =>
                 editId === ev.id ? (
                   <li key={ev.id}>
                     <form
@@ -549,9 +997,18 @@ export default function PersonDetailPage() {
                   <li key={ev.id} className="flex flex-wrap items-center justify-between gap-2 text-sm">
                     <span>
                       <span className="font-medium capitalize">{ev.event_type}</span>
+                      {ev.relationship_id ? (
+                        <span className="text-[var(--muted)]">
+                          {" "}
+                          · with {nameOf(spouseOfRelEvent(ev.relationship_id) ?? "")}
+                        </span>
+                      ) : null}
                       {ev.date_value ? (
                         <span className="text-[var(--muted)]"> — {ev.date_value}</span>
                       ) : null}
+                      {ev.detail ? (
+                        <span className="text-[var(--muted)]"> — {ev.detail}</span>
+                      ) : null}
                     </span>
                     <span className="flex items-center gap-3">
                       {citeControl(`e:${ev.id}`, { event_id: ev.id }, eventCites(ev.id))}
@@ -600,6 +1057,23 @@ export default function PersonDetailPage() {
                 />
               </label>
             )}
+            {isPartnershipType(evType) && (
+              <label className="flex flex-col gap-1">
+                <span className="text-xs text-[var(--muted)]">Spouse / partner</span>
+                <select
+                  className={fieldCls}
+                  value={evSpouse}
+                  onChange={(e) => setEvSpouse(e.target.value)}
+                >
+                  <option value="">— choose —</option>
+                  {others.map((p) => (
+                    <option key={p.id} value={p.id}>
+                      {p.primary_name ?? "Unnamed"}
+                    </option>
+                  ))}
+                </select>
+              </label>
+            )}
             <label className="flex flex-col gap-1">
               <span className="text-xs text-[var(--muted)]">When</span>
               <select className={fieldCls} value={dateQual} onChange={(e) => setDateQual(e.target.value)}>
@@ -672,14 +1146,13 @@ export default function PersonDetailPage() {
                 <option value="partner">partner</option>
                 <option value="sibling">sibling</option>
               </select>
-              <select className={fieldCls} value={relOther} onChange={(e) => setRelOther(e.target.value)}>
+              <PersonCombobox
-                <option value="">— person —</option>
+                people={others}
-                {others.map((p) => (
+                value={relOther}
-                  <option key={p.id} value={p.id}>
+                onChange={setRelOther}
-                    {p.primary_name ?? "Unnamed"}
+                onCreate={createRelativeAndGo}
-                  </option>
+                placeholder="Search, or type a new name…"
-                ))}
+              />
-              </select>
               {(relKind === "parent" || relKind === "child") && (
                 <select className={fieldCls} value={relQual} onChange={(e) => setRelQual(e.target.value as Qualifier)}>
                   {QUALIFIERS.map((q) => (
@@ -692,6 +1165,88 @@ export default function PersonDetailPage() {
               <Button type="submit">Link</Button>
             </form>
           )}
+          {relErr && <p className="text-sm text-red-600">{relErr}</p>}
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle className="text-base">Media</CardTitle>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          {(() => {
+            const personMedia = media.filter((m) => m.person_id === personId);
+            const unlinked = media.filter((m) => !m.person_id);
+            return (
+              <>
+                {personMedia.length === 0 ? (
+                  <p className="text-sm text-[var(--muted)]">No media linked to this person yet.</p>
+                ) : (
+                  <div className="grid grid-cols-2 gap-4 sm:grid-cols-3">
+                    {personMedia.map((m) => (
+                      <div key={m.id} className="overflow-hidden rounded-lg border border-[var(--border)]">
+                        <a href={m.url ?? "#"} target="_blank" rel="noreferrer" className="block">
+                          {m.content_type.startsWith("image/") ? (
+                            // eslint-disable-next-line @next/next/no-img-element
+                            <img
+                              src={m.url ?? ""}
+                              alt={m.title ?? m.original_filename}
+                              className="aspect-square w-full object-cover"
+                            />
+                          ) : (
+                            <div className="grid aspect-square w-full place-items-center bg-bronze/[0.06] font-serif text-2xl text-bronze">
+                              {(m.original_filename.split(".").pop() ?? "file").toUpperCase()}
+                            </div>
+                          )}
+                        </a>
+                        <div className="flex items-center justify-between gap-2 p-2">
+                          <span className="truncate text-xs" title={m.original_filename}>
+                            {m.title ?? m.original_filename}
+                          </span>
+                          <button
+                            onClick={() => linkMedia(m.id, false)}
+                            className="shrink-0 text-xs text-[var(--muted)] hover:text-bronze"
+                          >
+                            unlink
+                          </button>
+                        </div>
+                      </div>
+                    ))}
+                  </div>
+                )}
+
+                <div className="flex flex-wrap items-center gap-2">
+                  <input
+                    ref={mediaFileRef}
+                    type="file"
+                    onChange={uploadMediaForPerson}
+                    className="hidden"
+                  />
+                  <Button
+                    size="sm"
+                    onClick={() => mediaFileRef.current?.click()}
+                    disabled={uploadingMedia}
+                  >
+                    {uploadingMedia ? "Uploading…" : "Upload & link"}
+                  </Button>
+                  {unlinked.length > 0 && (
+                    <select
+                      className={fieldCls}
+                      defaultValue=""
+                      onChange={(e) => e.target.value && linkMedia(e.target.value, true)}
+                    >
+                      <option value="">Link existing media…</option>
+                      {unlinked.map((m) => (
+                        <option key={m.id} value={m.id}>
+                          {m.title ?? m.original_filename}
+                        </option>
+                      ))}
+                    </select>
+                  )}
+                </div>
+              </>
+            );
+          })()}
         </CardContent>
       </Card>
     </div>

frontend/app/trees/[id]/tree/chart.css

@@ -530,6 +530,11 @@
 
 .f3 .link {
   transition: stroke-width 0.2s ease-in-out;
+  /* Brand-aware connector lines: dark on the light paper, light on dark. The
+     library's default white stroke is invisible on the light theme. */
+  fill: none;
+  stroke: var(--line);
+  stroke-width: 1.5px;
 }
 
 .f3 .link.f3-path-to-main {

frontend/app/trees/[id]/tree/page.tsx

@@ -4,12 +4,13 @@
 import "./chart.css";
 
 import Link from "next/link";
-import { useParams, useRouter } from "next/navigation";
+import { useParams, useRouter, useSearchParams } from "next/navigation";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 import { api } from "@/lib/api/client";
 import type { components } from "@/lib/api/schema";
 import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
 import { FanChart } from "@/components/fan-chart";
 
 type Person = components["schemas"]["PersonRead"];
@@ -26,15 +27,25 @@ function splitName(name: string | null | undefined): [string, string] {
 export default function TreePage() {
   const router = useRouter();
   const params = useParams<{ id: string }>();
+  const searchParams = useSearchParams();
   const treeId = params.id;
+  // The focused person can arrive in the URL (?focus=…) — e.g. coming back from
+  // a person page. Captured once at mount so syncing focus→URL doesn't refetch.
+  const initialFocus = useRef<string | null>(searchParams.get("focus"));
   const containerRef = useRef<HTMLDivElement>(null);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const chartRef = useRef<any>(null);
+  const [query, setQuery] = useState("");
 
   const [people, setPeople] = useState<Person[]>([]);
   const [rels, setRels] = useState<Relationship[]>([]);
   const [events, setEvents] = useState<Event[]>([]);
   const [status, setStatus] = useState<"loading" | "empty" | "ready" | "error">("loading");
   const [focusId, setFocusId] = useState<string | null>(null);
+  // The tree's default/home person — lets us offer a "recenter on default" jump.
+  const [homeId, setHomeId] = useState<string | null>(null);
   const [mode, setMode] = useState<Mode>("landscape");
+  const [renderNote, setRenderNote] = useState<string | null>(null);
 
   useEffect(() => {
     let cancelled = false;
@@ -46,16 +57,25 @@ export default function TreePage() {
         router.push("/login");
         return;
       }
-      const [r, e] = await Promise.all([
+      const [r, e, t] = await Promise.all([
         api.GET("/api/v1/trees/{tree_id}/relationships", { params: { path: { tree_id: treeId } } }),
         api.GET("/api/v1/trees/{tree_id}/events", { params: { path: { tree_id: treeId } } }),
+        api.GET("/api/v1/trees/{tree_id}", { params: { path: { tree_id: treeId } } }),
       ]);
       if (cancelled) return;
       const ppl = p.data ?? [];
+      const home = t.data?.home_person_id ?? null;
+      const homeId = home && ppl.some((x) => x.id === home) ? home : null;
       setPeople(ppl);
       setRels(r.data ?? []);
       setEvents(e.data ?? []);
-      setFocusId((cur) => cur ?? ppl[0]?.id ?? null);
+      setHomeId(homeId);
+      // Honor an explicit ?focus first (came from a person page / a shared
+      // link), then the tree's default/home person, then the first person.
+      const fromUrl = initialFocus.current && ppl.some((x) => x.id === initialFocus.current)
+        ? initialFocus.current
+        : null;
+      setFocusId((cur) => cur ?? fromUrl ?? homeId ?? ppl[0]?.id ?? null);
       setStatus(ppl.length ? "ready" : "empty");
     })().catch(() => !cancelled && setStatus("error"));
     return () => {
@@ -100,6 +120,46 @@ export default function TreePage() {
     if (status !== "ready" || mode === "fan" || !containerRef.current) return;
     let cancelled = false;
     (async () => {
+      // Sanitize the graph before handing it to family-chart, which recurses
+      // through parents and will blow the stack (blank tree) on a cycle — e.g. a
+      // person edited into being their own ancestor.
+      const alive = new Set(people.map((pp) => pp.id));
+      const ok = (ids: string[], self: string) =>
+        [...new Set(ids)].filter((id) => alive.has(id) && id !== self);
+
+      // Build an acyclic set of parent edges: skip any edge that would make a
+      // person their own ancestor. Children are derived from the kept edges so
+      // parent/child stays consistent.
+      const parentsMap = new Map<string, string[]>();
+      const childrenMap = new Map<string, string[]>();
+      let dropped = 0;
+      const isAncestorOf = (ancestor: string, of: string): boolean => {
+        const stack = [...(parentsMap.get(of) ?? [])];
+        const seen = new Set<string>();
+        while (stack.length) {
+          const n = stack.pop()!;
+          if (n === ancestor) return true;
+          if (seen.has(n)) continue;
+          seen.add(n);
+          for (const p of parentsMap.get(n) ?? []) stack.push(p);
+        }
+        return false;
+      };
+      for (const pp of people) {
+        const accepted: string[] = [];
+        for (const par of ok(parentsOf(pp.id), pp.id)) {
+          // Edge "pp has parent par" loops if pp is already an ancestor of par.
+          if (isAncestorOf(pp.id, par)) {
+            dropped++;
+            continue;
+          }
+          accepted.push(par);
+          parentsMap.set(pp.id, accepted);
+          childrenMap.set(par, [...(childrenMap.get(par) ?? []), pp.id]);
+        }
+        parentsMap.set(pp.id, accepted);
+      }
+
       const data = people.map((pp) => {
         const [fn, ln] = splitName(pp.primary_name);
         return {
@@ -110,28 +170,48 @@ export default function TreePage() {
             birthday: years.get(pp.id) ?? "",
             gender: pp.gender === "female" ? "F" : "M",
           },
-          rels: { spouses: partnersOf(pp.id), parents: parentsOf(pp.id), children: childrenOf(pp.id) },
+          rels: {
+            spouses: ok(partnersOf(pp.id), pp.id),
+            parents: parentsMap.get(pp.id) ?? [],
+            children: childrenMap.get(pp.id) ?? [],
+          },
         };
       });
       const f3 = await import("family-chart");
       if (cancelled || !containerRef.current) return;
-      containerRef.current.innerHTML = "";
+      try {
-      const chart = f3.createChart(containerRef.current, data);
+        containerRef.current.innerHTML = "";
-      chart
+        const chart = f3.createChart(containerRef.current, data);
-        .setCardHtml()
+        chart.setCardHtml().setCardDisplay([["first name", "last name"], ["birthday"]]);
-        .setCardDisplay([["first name", "last name"], ["birthday"]])
+        if (mode === "portrait") chart.setOrientationVertical();
-        .setOnCardClick((_e: unknown, d: { data?: { id?: string } }) => {
+        else chart.setOrientationHorizontal();
-          const id = d?.data?.id;
+        // Show enough generations that a recenter reveals grandparents + children.
-          if (id) {
+        chart.setAncestryDepth?.(3);
-            setFocusId(id);
+        chart.setProgenyDepth?.(2);
-            chart.updateMainId(id);
+        // Default card click recenters the whole hourglass; sync focus for the
-            chart.updateTree();
+        // "Open profile" link after every (re)build.
-          }
+        chart.setAfterUpdate?.(() => {
+          const md = chart.getMainDatum?.();
+          const id = md?.id ?? md?.data?.id;
+          if (id) setFocusId(id);
         });
-      if (mode === "portrait") chart.setOrientationVertical();
+        chartRef.current = chart;
-      else chart.setOrientationHorizontal();
+        if (focusId) chart.updateMainId(focusId);
-      if (focusId) chart.updateMainId(focusId);
+        chart.updateTree({ initial: true });
-      chart.updateTree({ initial: true });
+        setRenderNote(
+          dropped > 0
+            ? `Skipped ${dropped} conflicting parent link${dropped === 1 ? "" : "s"} (a person can't be their own ancestor). Open the people involved to fix the relationship.`
+            : null,
+        );
+      } catch (err) {
+        // Never leave a blank canvas — show a message and let them fix via the
+        // Family view / person pages.
+        console.error("tree render failed", err);
+        if (containerRef.current) containerRef.current.innerHTML = "";
+        setRenderNote(
+          "The tree couldn't be drawn — a relationship may be conflicting. Use the Family view to open the affected people and check their parents/children.",
+        );
+      }
     })();
     return () => {
       cancelled = true;
@@ -139,6 +219,37 @@ export default function TreePage() {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [status, mode, people, rels, events]);
 
+  // Jump the tree (or fan) to a person and rebuild the hourglass around them.
+  const goTo = useCallback(
+    (id: string) => {
+      setFocusId(id);
+      setQuery("");
+      if (mode !== "fan" && chartRef.current) {
+        chartRef.current.updateMainId?.(id);
+        chartRef.current.updateTree?.();
+      }
+    },
+    [mode],
+  );
+
+  // Mirror the focused person into the URL (?focus=…) so navigating away and
+  // back — or sharing the link — keeps the tree centered where you left it.
+  // `replace` (not push) so each recenter doesn't pile up in browser history.
+  useEffect(() => {
+    if (!focusId || searchParams.get("focus") === focusId) return;
+    const sp = new URLSearchParams(searchParams.toString());
+    sp.set("focus", focusId);
+    router.replace(`/trees/${treeId}/tree?${sp.toString()}`, { scroll: false });
+  }, [focusId, searchParams, router, treeId]);
+
+  const matches = useMemo(() => {
+    const q = query.trim().toLowerCase();
+    if (!q) return [];
+    return people
+      .filter((p) => (p.primary_name ?? "").toLowerCase().includes(q))
+      .slice(0, 8);
+  }, [query, people]);
+
   const ModeButton = ({ m, label }: { m: Mode; label: string }) => (
     <button
       onClick={() => setMode(m)}
@@ -153,7 +264,44 @@ export default function TreePage() {
   return (
     <div className="space-y-4">
       <div className="flex flex-wrap items-center justify-between gap-3">
-        <h1 className="text-2xl font-semibold">Tree</h1>
+        <div className="flex items-center gap-3">
+          <h1 className="text-2xl font-semibold">Tree</h1>
+          <div className="relative">
+            <Input
+              value={query}
+              onChange={(e) => setQuery(e.target.value)}
+              placeholder="Find a person…"
+              className="w-56"
+            />
+            {matches.length > 0 && (
+              <ul className="absolute z-20 mt-1 w-72 overflow-hidden rounded-lg border border-[var(--border)] bg-[var(--surface)] shadow-lg">
+                {matches.map((p) => (
+                  <li key={p.id}>
+                    <button
+                      onClick={() => goTo(p.id)}
+                      className="flex w-full items-center justify-between gap-3 px-3 py-2 text-left text-sm hover:bg-[var(--muted-bg,rgba(0,0,0,0.04))]"
+                    >
+                      <span>{p.primary_name ?? "Unnamed"}</span>
+                      {yearOf(p.id) && (
+                        <span className="text-xs text-[var(--muted)]">{yearOf(p.id)}</span>
+                      )}
+                    </button>
+                  </li>
+                ))}
+              </ul>
+            )}
+          </div>
+          {homeId && focusId !== homeId && (
+            <button
+              onClick={() => goTo(homeId)}
+              className="text-sm text-bronze hover:underline"
+              title={`Recenter on the tree's default person (${nameOf(homeId)})`}
+            >
+              ↩ Back to default person
+              <span className="text-[var(--muted)]"> · {nameOf(homeId)}</span>
+            </button>
+          )}
+        </div>
         <div className="flex items-center gap-3">
           <div className="flex items-center rounded-lg border border-[var(--border)] p-0.5">
             <ModeButton m="landscape" label="Landscape" />
@@ -162,7 +310,7 @@ export default function TreePage() {
           </div>
           {focusId && (
             <Link
-              href={`/trees/${treeId}/persons/${focusId}`}
+              href={`/trees/${treeId}/persons/${focusId}?from=tree`}
               className="text-sm text-bronze hover:underline"
             >
               Open {nameOf(focusId)} →
@@ -176,6 +324,12 @@ export default function TreePage() {
       )}
       {status === "error" && <p className="text-[var(--muted)]">Could not render the tree.</p>}
 
+      {renderNote && mode !== "fan" && (
+        <p className="rounded-md border border-bronze/40 bg-bronze/[0.06] px-3 py-2 text-sm text-bronze">
+          {renderNote}
+        </p>
+      )}
+
       {status === "ready" && mode === "fan" && focusId ? (
         <div className="rounded-xl border border-[var(--border)] bg-[var(--surface)] p-4">
           <FanChart

frontend/app/trees/layout.tsx

@@ -1,28 +1,5 @@
-import Link from "next/link";
+import { AppShell } from "@/components/app-shell";
-
-import { AppSidebar } from "@/components/app-sidebar";
 
 export default function TreesLayout({ children }: { children: React.ReactNode }) {
-  return (
+  return <AppShell>{children}</AppShell>;
-    <div className="flex min-h-screen">
-      <aside className="sticky top-0 hidden h-screen w-64 shrink-0 border-r border-[var(--border)] bg-[var(--surface)] md:flex md:flex-col">
-        <AppSidebar />
-      </aside>
-
-      <div className="flex min-w-0 flex-1 flex-col">
-        {/* Compact bar for small screens (full sidebar is md+). */}
-        <div className="flex items-center justify-between border-b border-[var(--border)] bg-[var(--surface)] px-4 py-3 md:hidden">
-          <Link href="/" aria-label="Provenance — home">
-            {/* eslint-disable-next-line @next/next/no-img-element */}
-            <img src="/provenance-logo-plain.svg" alt="Provenance" className="h-6 w-auto" />
-          </Link>
-          <Link href="/trees" className="text-sm text-bronze">
-            Trees
-          </Link>
-        </div>
-
-        <div className="mx-auto w-full max-w-4xl px-6 py-10 md:px-10">{children}</div>
-      </div>
-    </div>
-  );
 }

frontend/components/app-shell.tsx

@@ -0,0 +1,69 @@
+"use client";
+
+import { Menu } from "lucide-react";
+import Link from "next/link";
+import { usePathname } from "next/navigation";
+import { useState } from "react";
+
+import { AppSidebar } from "@/components/app-sidebar";
+
+/**
+ * App chrome: a fixed sidebar on md+, and on small screens a top bar with a
+ * hamburger that opens the same sidebar as a slide-in drawer.
+ */
+export function AppShell({ children }: { children: React.ReactNode }) {
+  const [open, setOpen] = useState(false);
+  const pathname = usePathname();
+  // The tree visualization wants the whole canvas; everything else reads better
+  // in a centered, max-width column.
+  const fullWidth = /^\/trees\/[^/]+\/tree$/.test(pathname);
+
+  return (
+    <div className="flex min-h-screen">
+      <aside className="sticky top-0 hidden h-screen w-64 shrink-0 border-r border-[var(--border)] bg-[var(--surface)] md:flex md:flex-col">
+        <AppSidebar />
+      </aside>
+
+      <div className="flex min-w-0 flex-1 flex-col">
+        {/* Mobile top bar */}
+        <div className="flex items-center gap-3 border-b border-[var(--border)] bg-[var(--surface)] px-4 py-3 md:hidden">
+          <button
+            onClick={() => setOpen(true)}
+            aria-label="Open menu"
+            className="text-[var(--muted)] hover:text-[var(--foreground)]"
+          >
+            <Menu className="h-6 w-6" />
+          </button>
+          <Link href="/" aria-label="Provenance — home">
+            {/* eslint-disable-next-line @next/next/no-img-element */}
+            <img src="/provenance-logo-plain.svg" alt="Provenance" className="h-6 w-auto" />
+          </Link>
+        </div>
+
+        {/* Mobile drawer */}
+        {open && (
+          <div className="fixed inset-0 z-50 md:hidden">
+            <div
+              className="absolute inset-0 bg-black/40"
+              onClick={() => setOpen(false)}
+              aria-hidden
+            />
+            <aside className="absolute left-0 top-0 h-full w-72 max-w-[85%] border-r border-[var(--border)] bg-[var(--surface)] shadow-xl">
+              <AppSidebar onNavigate={() => setOpen(false)} />
+            </aside>
+          </div>
+        )}
+
+        <div
+          className={
+            fullWidth
+              ? "w-full px-4 py-6 md:px-6"
+              : "mx-auto w-full max-w-4xl px-6 py-10 md:px-10"
+          }
+        >
+          {children}
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/components/app-sidebar.tsx

@@ -8,21 +8,27 @@ import {
   Image as ImageIcon,
   LogOut,
   Network,
+  Settings,
+  Sparkles,
   Users,
 } from "lucide-react";
 import Link from "next/link";
 import { usePathname, useRouter } from "next/navigation";
-import { useEffect, useState } from "react";
+import { useEffect, useRef, useState } from "react";
 
 import { api } from "@/lib/api/client";
 import { cn } from "@/lib/utils";
+import { ThemeToggle } from "@/components/theme-toggle";
 
-export function AppSidebar() {
+export function AppSidebar({ onNavigate }: { onNavigate?: () => void }) {
   const pathname = usePathname();
   const router = useRouter();
   const segs = pathname.split("/").filter(Boolean); // ["trees", "<id>", ...]
   const treeId = segs[0] === "trees" && segs[1] ? segs[1] : null;
   const [treeName, setTreeName] = useState<string | null>(null);
+  const [me, setMe] = useState<{ display_name: string | null; email: string } | null>(null);
+  const [menuOpen, setMenuOpen] = useState(false);
+  const menuRef = useRef<HTMLDivElement>(null);
 
   useEffect(() => {
     if (!treeId) {
@@ -34,7 +40,20 @@ export function AppSidebar() {
       .then((r) => setTreeName(r.data?.name ?? null));
   }, [treeId]);
 
+  useEffect(() => {
+    api.GET("/api/v1/users/me").then((r) => setMe(r.data ?? null));
+  }, []);
+
+  useEffect(() => {
+    function onDoc(e: MouseEvent) {
+      if (menuRef.current && !menuRef.current.contains(e.target as Node)) setMenuOpen(false);
+    }
+    document.addEventListener("mousedown", onDoc);
+    return () => document.removeEventListener("mousedown", onDoc);
+  }, []);
+
   async function logout() {
+    onNavigate?.();
     await api.POST("/api/v1/auth/logout");
     router.push("/login");
   }
@@ -52,6 +71,7 @@ export function AppSidebar() {
   }) => (
     <Link
       href={href}
+      onClick={onNavigate}
       className={cn(
         "flex items-center gap-3 rounded-lg px-3 py-2 text-sm transition-colors",
         active
@@ -72,6 +92,7 @@ export function AppSidebar() {
       </Link>
 
       <Item href="/trees" label="Trees" icon={FolderTree} active={pathname === "/trees"} />
+      <Item href="/import" label="Import" icon={ArrowDownUp} active={pathname === "/import"} />
 
       {treeId && (
         <div className="mt-5 flex flex-col gap-1">
@@ -108,6 +129,12 @@ export function AppSidebar() {
             icon={ArrowDownUp}
             active={pathname.startsWith(`/trees/${treeId}/gedcom`)}
           />
+          <Item
+            href={`/trees/${treeId}/cleanup`}
+            label="Cleanup"
+            icon={Sparkles}
+            active={pathname.startsWith(`/trees/${treeId}/cleanup`)}
+          />
           <Item
             href={`/trees/${treeId}/recovery`}
             label="Recovery"
@@ -117,13 +144,45 @@ export function AppSidebar() {
         </div>
       )}
 
-      <button
+      <div className="mt-auto">
-        onClick={logout}
+        <ThemeToggle />
-        className="mt-auto flex items-center gap-3 rounded-lg px-3 py-2 text-sm text-[var(--muted)] transition-colors hover:bg-bronze/[0.07] hover:text-bronze"
+      </div>
-      >
+
-        <LogOut className="h-4 w-4 shrink-0" />
+      <div ref={menuRef} className="relative">
-        Sign out
+        {menuOpen && (
-      </button>
+          <div className="absolute bottom-full left-0 mb-2 w-full overflow-hidden rounded-lg border border-[var(--border)] bg-[var(--surface)] shadow-lg">
+            <Link
+              href="/settings"
+              onClick={() => {
+                setMenuOpen(false);
+                onNavigate?.();
+              }}
+              className="flex items-center gap-3 px-3 py-2 text-sm text-[var(--muted)] hover:bg-bronze/[0.07] hover:text-[var(--foreground)]"
+            >
+              <Settings className="h-4 w-4 shrink-0" />
+              Settings
+            </Link>
+            <button
+              onClick={logout}
+              className="flex w-full items-center gap-3 px-3 py-2 text-sm text-[var(--muted)] hover:bg-bronze/[0.07] hover:text-bronze"
+            >
+              <LogOut className="h-4 w-4 shrink-0" />
+              Sign out
+            </button>
+          </div>
+        )}
+        <button
+          onClick={() => setMenuOpen((o) => !o)}
+          className="flex w-full items-center gap-3 rounded-lg px-3 py-2 text-left text-sm text-[var(--foreground)] transition-colors hover:bg-bronze/[0.07]"
+        >
+          <span className="flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-bronze/15 text-xs font-semibold uppercase text-bronze">
+            {(me?.display_name || me?.email || "?").slice(0, 1)}
+          </span>
+          <span className="min-w-0 flex-1 truncate">
+            {me?.display_name || me?.email || "Account"}
+          </span>
+        </button>
+      </div>
     </nav>
   );
 }

frontend/components/fan-chart.tsx

@@ -79,7 +79,7 @@ export function FanChart({
           <path
             d={sector(r0 + 1, r1 - 1, a0 + 0.004, a1 - 0.004)}
             fill={id ? "var(--surface)" : "transparent"}
-            stroke="var(--border)"
+            stroke="var(--line)"
           />
           {id && (
             <text

frontend/components/gedcom-import.tsx

@@ -0,0 +1,331 @@
+"use client";
+
+import Link from "next/link";
+import { useEffect, useRef, useState } from "react";
+
+import { api } from "@/lib/api/client";
+import type { components } from "@/lib/api/schema";
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+
+type Report = { counts: Record<string, number>; unmapped_tags: string[] };
+type Preview = components["schemas"]["ImportPreview"];
+type Dup = components["schemas"]["DuplicateMatch"];
+type Tree = components["schemas"]["TreeRead"];
+type Action = "new" | "skip" | "merge" | "overwrite";
+
+const ACTIONS: { value: Action; label: string }[] = [
+  { value: "new", label: "Import as new" },
+  { value: "merge", label: "Merge into existing" },
+  { value: "skip", label: "Skip (use existing)" },
+  { value: "overwrite", label: "Overwrite existing" },
+];
+
+const fieldCls = "h-9 rounded-md border border-[var(--border)] bg-[var(--surface)] px-2 text-sm";
+
+/**
+ * GEDCOM import with a selectable destination (a new tree, or an existing one).
+ * Importing into an existing tree previews likely duplicates so each can be
+ * resolved (new / skip / merge / overwrite) before anything is written.
+ *
+ * @param fixedTreeId  When set, the destination defaults to that tree (the
+ *   tree-scoped Import page). When omitted (the global Import page), the user
+ *   picks a destination.
+ */
+export function GedcomImport({ fixedTreeId }: { fixedTreeId?: string }) {
+  const [trees, setTrees] = useState<Tree[]>([]);
+  const [mode, setMode] = useState<"new" | "existing">(fixedTreeId ? "existing" : "new");
+  const [chosenTreeId, setChosenTreeId] = useState(fixedTreeId ?? "");
+  const [newName, setNewName] = useState("");
+
+  const [busy, setBusy] = useState(false);
+  const [report, setReport] = useState<Report | null>(null);
+  const [importedTreeId, setImportedTreeId] = useState<string | null>(null);
+  const [file, setFile] = useState<File | null>(null);
+  const [preview, setPreview] = useState<Preview | null>(null);
+  const [resolutions, setResolutions] = useState<Record<string, Action>>({});
+  const fileRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    api.GET("/api/v1/trees").then((r) => setTrees(r.data ?? []));
+  }, []);
+
+  function resetRun() {
+    setReport(null);
+    setImportedTreeId(null);
+    setPreview(null);
+    setFile(null);
+    setResolutions({});
+  }
+
+  async function postImport(tid: string, f: File, resolutionsJson?: string) {
+    const fd = new FormData();
+    fd.append("file", f);
+    if (resolutionsJson) fd.append("resolutions", resolutionsJson);
+    const resp = await fetch(`/api/v1/trees/${tid}/gedcom/import`, {
+      method: "POST",
+      body: fd,
+      credentials: "include",
+    });
+    if (resp.ok) {
+      setReport(await resp.json());
+      setImportedTreeId(tid);
+    }
+  }
+
+  async function onFile(e: React.ChangeEvent<HTMLInputElement>) {
+    const f = e.target.files?.[0];
+    if (fileRef.current) fileRef.current.value = "";
+    if (!f) return;
+    setBusy(true);
+    resetRun();
+
+    if (mode === "new") {
+      const { data } = await api.POST("/api/v1/trees", {
+        body: { name: newName.trim() || "Imported tree" },
+      });
+      if (data) await postImport(data.id, f);
+      setBusy(false);
+      return;
+    }
+
+    if (!chosenTreeId) {
+      setBusy(false);
+      return;
+    }
+
+    // Existing tree — preview duplicates first.
+    setFile(f);
+    const fd = new FormData();
+    fd.append("file", f);
+    const resp = await fetch(`/api/v1/trees/${chosenTreeId}/gedcom/preview`, {
+      method: "POST",
+      body: fd,
+      credentials: "include",
+    });
+    if (resp.ok) {
+      const pv: Preview = await resp.json();
+      setPreview(pv);
+      const init: Record<string, Action> = {};
+      for (const d of pv.potential_duplicates) init[d.xref] = d.score === "high" ? "merge" : "new";
+      setResolutions(init);
+    }
+    setBusy(false);
+  }
+
+  async function runImport() {
+    if (!file || !chosenTreeId) return;
+    setBusy(true);
+    const map: Record<string, { action: Action; target_id: string }> = {};
+    for (const d of preview?.potential_duplicates ?? []) {
+      const action = resolutions[d.xref] ?? "new";
+      if (action !== "new") map[d.xref] = { action, target_id: d.existing_person_id };
+    }
+    await postImport(chosenTreeId, file, JSON.stringify(map));
+    setPreview(null);
+    setFile(null);
+    setBusy(false);
+  }
+
+  const dups = preview?.potential_duplicates ?? [];
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle className="text-base">Import a GEDCOM file</CardTitle>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        {!preview && (
+          <>
+            <label className="flex items-center gap-2 text-sm">
+              <input
+                type="radio"
+                checked={mode === "new"}
+                onChange={() => {
+                  setMode("new");
+                  resetRun();
+                }}
+              />
+              Import into a <strong>new tree</strong>
+            </label>
+            {mode === "new" && (
+              <Input
+                className="max-w-xs"
+                placeholder="New tree name"
+                value={newName}
+                onChange={(e) => setNewName(e.target.value)}
+              />
+            )}
+
+            <label className="flex items-center gap-2 text-sm">
+              <input
+                type="radio"
+                checked={mode === "existing"}
+                onChange={() => {
+                  setMode("existing");
+                  resetRun();
+                }}
+              />
+              Import into an <strong>existing tree</strong> (checks for duplicates)
+            </label>
+            {mode === "existing" && (
+              <select
+                className={`${fieldCls} max-w-xs`}
+                value={chosenTreeId}
+                onChange={(e) => setChosenTreeId(e.target.value)}
+              >
+                <option value="">— choose a tree —</option>
+                {trees.map((t) => (
+                  <option key={t.id} value={t.id}>
+                    {t.name}
+                  </option>
+                ))}
+              </select>
+            )}
+
+            <input
+              ref={fileRef}
+              type="file"
+              accept=".ged,.gedcom,text/plain"
+              onChange={onFile}
+              className="hidden"
+            />
+            <Button
+              onClick={() => fileRef.current?.click()}
+              disabled={busy || (mode === "existing" && !chosenTreeId)}
+            >
+              {busy ? "Working…" : "Choose GEDCOM file"}
+            </Button>
+          </>
+        )}
+
+        {/* Duplicate-resolution step */}
+        {preview && (
+          <div className="space-y-4">
+            <div className="flex flex-wrap gap-x-6 gap-y-1 text-sm text-[var(--muted)]">
+              {Object.entries(preview.counts).map(([k, v]) => (
+                <span key={k}>
+                  <span className="font-medium text-[var(--foreground)]">{v}</span> {k}
+                </span>
+              ))}
+            </div>
+
+            {dups.length === 0 ? (
+              <p className="rounded-md bg-bronze/[0.08] px-3 py-2 text-sm">
+                No likely duplicates found — everyone will be imported as new.
+              </p>
+            ) : (
+              <div className="space-y-2">
+                <div className="flex items-center justify-between">
+                  <h3 className="text-sm font-semibold">
+                    {dups.length} possible duplicate{dups.length === 1 ? "" : "s"}
+                  </h3>
+                  <label className="flex items-center gap-2 text-xs text-[var(--muted)]">
+                    Set all to
+                    <select
+                      className={fieldCls}
+                      defaultValue=""
+                      onChange={(e) => {
+                        const a = e.target.value as Action;
+                        const all: Record<string, Action> = {};
+                        for (const d of dups) all[d.xref] = a;
+                        setResolutions(all);
+                      }}
+                    >
+                      <option value="" disabled>
+                        choose…
+                      </option>
+                      {ACTIONS.map((a) => (
+                        <option key={a.value} value={a.value}>
+                          {a.label}
+                        </option>
+                      ))}
+                    </select>
+                  </label>
+                </div>
+                <ul className="divide-y divide-[var(--border)] rounded-lg border border-[var(--border)]">
+                  {dups.map((d: Dup) => (
+                    <li
+                      key={d.xref}
+                      className="flex flex-wrap items-center justify-between gap-3 px-3 py-2 text-sm"
+                    >
+                      <div className="min-w-0">
+                        <span className="font-medium">{d.incoming_name}</span>
+                        {d.incoming_birth_year && (
+                          <span className="text-[var(--muted)]"> b. {d.incoming_birth_year}</span>
+                        )}
+                        <span className="text-[var(--muted)]"> ↔ </span>
+                        <span>{d.existing_name}</span>
+                        {d.existing_birth_year && (
+                          <span className="text-[var(--muted)]"> b. {d.existing_birth_year}</span>
+                        )}
+                        <span
+                          className={`ml-2 rounded px-1.5 py-0.5 text-xs ${
+                            d.score === "high"
+                              ? "bg-bronze/15 text-bronze"
+                              : "bg-[var(--border)]/50 text-[var(--muted)]"
+                          }`}
+                        >
+                          {d.score}
+                        </span>
+                      </div>
+                      <select
+                        className={fieldCls}
+                        value={resolutions[d.xref] ?? "new"}
+                        onChange={(e) =>
+                          setResolutions((r) => ({ ...r, [d.xref]: e.target.value as Action }))
+                        }
+                      >
+                        {ACTIONS.map((a) => (
+                          <option key={a.value} value={a.value}>
+                            {a.label}
+                          </option>
+                        ))}
+                      </select>
+                    </li>
+                  ))}
+                </ul>
+              </div>
+            )}
+
+            <div className="flex gap-2">
+              <Button onClick={runImport} disabled={busy}>
+                {busy ? "Importing…" : "Run import"}
+              </Button>
+              <Button variant="ghost" onClick={resetRun} disabled={busy}>
+                Cancel
+              </Button>
+            </div>
+          </div>
+        )}
+
+        {report && (
+          <div className="space-y-3 rounded-lg border border-[var(--border)] p-4">
+            <div className="font-medium">Import complete</div>
+            <div className="flex flex-wrap gap-x-6 gap-y-1 text-sm text-[var(--muted)]">
+              {Object.entries(report.counts).map(([k, v]) => (
+                <span key={k}>
+                  <span className="font-medium text-[var(--foreground)]">{v}</span> {k}
+                </span>
+              ))}
+            </div>
+            {report.unmapped_tags.length > 0 && (
+              <div className="text-xs text-[var(--muted)]">
+                Unmapped tags (skipped): {report.unmapped_tags.join(", ")}
+              </div>
+            )}
+            {importedTreeId && (
+              <Link
+                href={`/trees/${importedTreeId}`}
+                className="inline-block text-sm text-bronze hover:underline"
+              >
+                Open the tree →
+              </Link>
+            )}
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

frontend/components/person-combobox.tsx

@@ -0,0 +1,121 @@
+"use client";
+
+import { useEffect, useMemo, useRef, useState } from "react";
+
+import type { components } from "@/lib/api/schema";
+
+type Person = components["schemas"]["PersonRead"];
+
+/**
+ * A type-to-filter person picker. Shows a text input; as you type, a dropdown
+ * of matching people appears. Selecting one sets `value` (a person id) and
+ * fills the input with their name. Replaces a plain <select> when the list is
+ * long enough that scanning it by hand is painful.
+ */
+export function PersonCombobox({
+  people,
+  value,
+  onChange,
+  onCreate,
+  placeholder = "Search for a person…",
+  className,
+}: {
+  people: Person[];
+  value: string;
+  onChange: (id: string) => void;
+  /** When set, the dropdown offers a "Create '<typed name>'" action. */
+  onCreate?: (name: string) => void;
+  placeholder?: string;
+  className?: string;
+}) {
+  const [query, setQuery] = useState("");
+  const [open, setOpen] = useState(false);
+  const wrapRef = useRef<HTMLDivElement>(null);
+
+  const nameOf = useMemo(
+    () => new Map(people.map((p) => [p.id, p.primary_name ?? "Unnamed"])),
+    [people],
+  );
+
+  // Keep the input text in sync when the selection changes externally
+  // (e.g. cleared to "" after a successful add).
+  useEffect(() => {
+    if (!value) {
+      setQuery("");
+    } else if (!open) {
+      setQuery(nameOf.get(value) ?? "");
+    }
+  }, [value, open, nameOf]);
+
+  // Close on outside click.
+  useEffect(() => {
+    function onDoc(e: MouseEvent) {
+      if (wrapRef.current && !wrapRef.current.contains(e.target as Node)) setOpen(false);
+    }
+    document.addEventListener("mousedown", onDoc);
+    return () => document.removeEventListener("mousedown", onDoc);
+  }, []);
+
+  const matches = useMemo(() => {
+    const q = query.trim().toLowerCase();
+    const pool = q
+      ? people.filter((p) => (p.primary_name ?? "").toLowerCase().includes(q))
+      : people;
+    return pool.slice(0, 10);
+  }, [query, people]);
+
+  const base =
+    "h-9 w-56 rounded-md border border-[var(--border)] bg-[var(--surface)] px-2 text-sm placeholder:text-[var(--muted)] focus-visible:border-bronze focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-bronze/40";
+
+  return (
+    <div ref={wrapRef} className="relative">
+      <input
+        className={`${base} ${className ?? ""}`}
+        value={query}
+        placeholder={placeholder}
+        onFocus={() => setOpen(true)}
+        onChange={(e) => {
+          setQuery(e.target.value);
+          setOpen(true);
+          if (value) onChange(""); // typing invalidates the prior pick
+        }}
+      />
+      {open && (matches.length > 0 || (onCreate && query.trim())) && (
+        <ul className="absolute z-30 mt-1 max-h-64 w-72 overflow-auto rounded-lg border border-[var(--border)] bg-[var(--surface)] shadow-lg">
+          {matches.map((p) => (
+            <li key={p.id}>
+              <button
+                type="button"
+                onClick={() => {
+                  onChange(p.id);
+                  setQuery(p.primary_name ?? "Unnamed");
+                  setOpen(false);
+                }}
+                className={`block w-full px-3 py-2 text-left text-sm hover:bg-[var(--muted-bg,rgba(0,0,0,0.04))] ${
+                  p.id === value ? "text-bronze" : ""
+                }`}
+              >
+                {p.primary_name ?? "Unnamed"}
+              </button>
+            </li>
+          ))}
+          {onCreate && query.trim() && (
+            <li className={matches.length > 0 ? "border-t border-[var(--border)]" : ""}>
+              <button
+                type="button"
+                onClick={() => {
+                  const name = query.trim();
+                  setOpen(false);
+                  onCreate(name);
+                }}
+                className="block w-full px-3 py-2 text-left text-sm text-bronze hover:bg-[var(--muted-bg,rgba(0,0,0,0.04))]"
+              >
+                + Create “{query.trim()}”
+              </button>
+            </li>
+          )}
+        </ul>
+      )}
+    </div>
+  );
+}

frontend/components/theme-toggle.tsx

@@ -0,0 +1,54 @@
+"use client";
+
+import { Monitor, Moon, Sun } from "lucide-react";
+import { useEffect, useState } from "react";
+
+type Theme = "light" | "dark" | "system";
+const ORDER: Theme[] = ["system", "light", "dark"];
+const ICON = { system: Monitor, light: Sun, dark: Moon };
+const LABEL = { system: "System", light: "Light", dark: "Dark" };
+
+function apply(theme: Theme) {
+  const dark =
+    theme === "dark" ||
+    (theme === "system" && window.matchMedia("(prefers-color-scheme: dark)").matches);
+  document.documentElement.classList.toggle("dark", dark);
+}
+
+/** Cycles theme System → Light → Dark, persisting the choice in localStorage. */
+export function ThemeToggle() {
+  const [theme, setTheme] = useState<Theme>("system");
+
+  useEffect(() => {
+    const saved = (localStorage.getItem("theme") as Theme) || "system";
+    setTheme(saved);
+  }, []);
+
+  // Keep "system" in sync if the OS preference changes while selected.
+  useEffect(() => {
+    if (theme !== "system") return;
+    const mq = window.matchMedia("(prefers-color-scheme: dark)");
+    const onChange = () => apply("system");
+    mq.addEventListener("change", onChange);
+    return () => mq.removeEventListener("change", onChange);
+  }, [theme]);
+
+  function cycle() {
+    const next = ORDER[(ORDER.indexOf(theme) + 1) % ORDER.length];
+    localStorage.setItem("theme", next);
+    setTheme(next);
+    apply(next);
+  }
+
+  const Icon = ICON[theme];
+  return (
+    <button
+      onClick={cycle}
+      className="flex w-full items-center gap-3 rounded-lg px-3 py-2 text-sm text-[var(--muted)] transition-colors hover:bg-bronze/[0.07] hover:text-[var(--foreground)]"
+      title={`Theme: ${LABEL[theme]} (click to change)`}
+    >
+      <Icon className="h-4 w-4 shrink-0" />
+      Theme: {LABEL[theme]}
+    </button>
+  );
+}