DB-canonical personas: CRUD + shared settings

README.md

@@ -109,10 +109,9 @@ After the conversation completes, the app runs post-conversation analysis and po
 
 ## 5. Personas
 
-- Surveyor definitions: `data/surveyor_personas.yaml`
-- Patient definitions: `data/patient_personas.yaml`
-
-Edit the YAML, then restart the backend to apply changes.
+- Personas are **DB-canonical** (SQLite at `DB_PATH`) and shared across users on Hugging Face Spaces.
+- On startup, the app seeds a small immutable default set (3 surveyors + 3 patients).
+- Create/duplicate/edit/delete **user personas** in the **Configuration** panel (defaults remain view-only).
 
 ---
 

backend/api/analysis_routes.py

@@ -13,7 +13,7 @@ from fastapi import APIRouter, File, Form, HTTPException, UploadFile
 from pydantic import BaseModel, Field
 
 from .conversation_service import run_resource_agent_analysis
-from .storage_service import get_run_store
+from .storage_service import get_run_store, get_persona_store
 from config.settings import get_settings
 from backend.storage import RunRecord
 
@@ -145,13 +145,14 @@ async def _analyze_from_text(
             text=msg["content"],
         ))
 
+    effective_analysis_attributes = await get_persona_store().get_setting("analysis_attributes")
     resources = await run_resource_agent_analysis(
         transcript=transcript,
         llm_backend=settings.llm.backend,
         host=settings.llm.host,
         model=settings.llm.model,
         settings=settings,
-        analysis_attributes=analysis_attributes,
+        analysis_attributes=effective_analysis_attributes,
     )
 
     persisted = False
@@ -172,7 +173,7 @@ async def _analyze_from_text(
                 "source_name": source_name,
             },
             "analysis": {
-                "analysis_attributes": analysis_attributes,
+                "analysis_attributes": effective_analysis_attributes,
             },
         }
         record = RunRecord(

backend/api/conversation_service.py

@@ -38,9 +38,10 @@ for path in (BACKEND_DIR, PROJECT_ROOT):
 from config.settings import AppSettings, get_settings  # noqa: E402
 from backend.core.conversation_manager import ConversationManager  # noqa: E402
 from backend.core.llm_client import create_llm_client  # noqa: E402
-from backend.core.persona_system import PersonaSystem  # noqa: E402
+from backend.core.persona_system import get_persona_system  # noqa: E402
 from .conversation_ws import ConnectionManager  # noqa: E402
 from .storage_service import get_run_store  # noqa: E402
+from .storage_service import get_persona_store  # noqa: E402
 from backend.storage import RunRecord  # noqa: E402
 from backend.core.surveyor_knobs import compile_surveyor_attributes_overlay, compile_question_bank_overlay  # noqa: E402
 from backend.core.patient_knobs import compile_patient_attributes_overlay  # noqa: E402
@@ -326,7 +327,7 @@ class ConversationService:
             settings: Shared application settings (optional)
         """
         self.websocket_manager = websocket_manager
-        self.persona_system = PersonaSystem()
+        self.persona_system = get_persona_system()
         self.active_conversations: Dict[str, ConversationInfo] = {}
         self.active_human_chats: Dict[str, HumanChatInfo] = {}
         self.transcripts: Dict[str, List[Dict[str, Any]]] = {}
@@ -359,10 +360,10 @@ class ConversationService:
         patient_persona_id: str,
         host: Optional[str] = None,
         model: Optional[str] = None,
-        patient_attributes: Optional[List[str]] = None,
-        surveyor_system_prompt: Optional[str] = None,
-        patient_system_prompt: Optional[str] = None,
-        analysis_attributes: Optional[List[str]] = None,
+        patient_attributes: Optional[List[str]] = None,  # deprecated (persona content is DB-canonical)
+        surveyor_system_prompt: Optional[str] = None,  # deprecated (DB-canonical)
+        patient_system_prompt: Optional[str] = None,  # deprecated (DB-canonical)
+        analysis_attributes: Optional[List[str]] = None,  # deprecated (DB-canonical)
         surveyor_attributes: Optional[List[str]] = None,
         surveyor_question_bank: Optional[str] = None,
         ai_role: Optional[str] = None,
@@ -384,6 +385,15 @@ class ConversationService:
 
         resolved_ai_role = ai_role if ai_role in ("surveyor", "patient") else "surveyor"
 
+        # DB-canonical settings (shared on HF)
+        store = get_persona_store()
+        sp = await store.get_setting("surveyor_system_prompt")
+        pp = await store.get_setting("patient_system_prompt")
+        ap = await store.get_setting("analysis_attributes")
+        resolved_surveyor_prompt = sp if isinstance(sp, str) and sp.strip() else DEFAULT_SURVEYOR_SYSTEM_PROMPT
+        resolved_patient_prompt = pp if isinstance(pp, str) and pp.strip() else DEFAULT_PATIENT_SYSTEM_PROMPT
+        resolved_analysis_attrs = [s.strip() for s in ap if isinstance(ap, str) and s.strip()] if isinstance(ap, list) else []
+
         chat_info = HumanChatInfo(
             conversation_id=conversation_id,
             surveyor_persona_id=surveyor_persona_id,
@@ -391,9 +401,9 @@ class ConversationService:
             host=resolved_host,
             model=resolved_model,
             llm_backend=resolved_backend,
-            surveyor_system_prompt=(surveyor_system_prompt or "").strip() or DEFAULT_SURVEYOR_SYSTEM_PROMPT,
-            patient_system_prompt=(patient_system_prompt or "").strip() or DEFAULT_PATIENT_SYSTEM_PROMPT,
-            analysis_attributes=[s.strip() for s in (analysis_attributes or []) if isinstance(s, str) and s.strip()],
+            surveyor_system_prompt=resolved_surveyor_prompt,
+            patient_system_prompt=resolved_patient_prompt,
+            analysis_attributes=resolved_analysis_attrs,
             patient_attributes=self._persona_attributes(patient_persona),
             surveyor_attributes=self._persona_attributes(surveyor_persona),
             surveyor_question_bank=self._persona_question_bank(surveyor_persona),
@@ -699,10 +709,10 @@ class ConversationService:
                                patient_persona_id: str,
                                host: Optional[str] = None,
                                model: Optional[str] = None,
-                               patient_attributes: Optional[List[str]] = None,
-                               surveyor_system_prompt: Optional[str] = None,
-                               patient_system_prompt: Optional[str] = None,
-                               analysis_attributes: Optional[List[str]] = None,
+                               patient_attributes: Optional[List[str]] = None,  # deprecated (DB-canonical)
+                               surveyor_system_prompt: Optional[str] = None,  # deprecated (DB-canonical)
+                               patient_system_prompt: Optional[str] = None,  # deprecated (DB-canonical)
+                               analysis_attributes: Optional[List[str]] = None,  # deprecated (DB-canonical)
                                surveyor_attributes: Optional[List[str]] = None,
                                surveyor_question_bank: Optional[str] = None) -> bool:
         """Start a new AI-to-AI conversation.
@@ -738,6 +748,14 @@ class ConversationService:
             resolved_model = model or self.settings.llm.model
             resolved_backend = self.settings.llm.backend
 
+            store = get_persona_store()
+            sp = await store.get_setting("surveyor_system_prompt")
+            pp = await store.get_setting("patient_system_prompt")
+            ap = await store.get_setting("analysis_attributes")
+            resolved_surveyor_prompt = sp if isinstance(sp, str) and sp.strip() else DEFAULT_SURVEYOR_SYSTEM_PROMPT
+            resolved_patient_prompt = pp if isinstance(pp, str) and pp.strip() else DEFAULT_PATIENT_SYSTEM_PROMPT
+            resolved_analysis_attrs = [s.strip() for s in ap if isinstance(ap, str) and s.strip()] if isinstance(ap, list) else []
+
             # Create conversation info
             conv_info = ConversationInfo(
                 conversation_id=conversation_id,
@@ -746,9 +764,9 @@ class ConversationService:
                 host=resolved_host,
                 model=resolved_model,
                 llm_backend=resolved_backend,
-                surveyor_system_prompt=(surveyor_system_prompt or "").strip() or DEFAULT_SURVEYOR_SYSTEM_PROMPT,
-                patient_system_prompt=(patient_system_prompt or "").strip() or DEFAULT_PATIENT_SYSTEM_PROMPT,
-                analysis_attributes=[s.strip() for s in (analysis_attributes or []) if isinstance(s, str) and s.strip()],
+                surveyor_system_prompt=resolved_surveyor_prompt,
+                patient_system_prompt=resolved_patient_prompt,
+                analysis_attributes=resolved_analysis_attrs,
                 patient_attributes=self._persona_attributes(patient_persona),
                 surveyor_attributes=self._persona_attributes(surveyor_persona),
                 surveyor_question_bank=self._persona_question_bank(surveyor_persona),
@@ -1028,8 +1046,16 @@ class ConversationService:
                     surveyor_persona = self.persona_system.get_persona(conv_info.surveyor_persona_id) or {}
                     patient_persona = self.persona_system.get_persona(conv_info.patient_persona_id) or {}
                     persona_snapshots = {
-                        "surveyor": {"persona_id": conv_info.surveyor_persona_id, "persona_version_id": None, "snapshot": surveyor_persona},
-                        "patient": {"persona_id": conv_info.patient_persona_id, "persona_version_id": None, "snapshot": patient_persona},
+                        "surveyor": {
+                            "persona_id": conv_info.surveyor_persona_id,
+                            "persona_version_id": surveyor_persona.get("version_id"),
+                            "snapshot": surveyor_persona,
+                        },
+                        "patient": {
+                            "persona_id": conv_info.patient_persona_id,
+                            "persona_version_id": patient_persona.get("version_id"),
+                            "snapshot": patient_persona,
+                        },
                     }
                 except Exception:
                     persona_snapshots = {}

backend/api/main.py

@@ -35,7 +35,7 @@ from .analysis_routes import router as analysis_router  # noqa: E402
 from .run_routes import router as run_router  # noqa: E402
 from .run_export_routes import router as run_export_router  # noqa: E402
 from .conversation_service import initialize_conversation_service  # noqa: E402
-from .storage_service import initialize_run_store  # noqa: E402
+from .storage_service import initialize_run_store, seed_personas_and_settings  # noqa: E402
 from backend.core.auth import COOKIE_NAME, INTERNAL_HEADER, get_app_password, verify_session_token  # noqa: E402
 
 # Load application settings
@@ -108,6 +108,7 @@ async def startup_event():
     # Initialize conversation service with WebSocket manager and settings
     initialize_conversation_service(manager, settings)
     await initialize_run_store(settings)
+    await seed_personas_and_settings(overwrite_defaults=True)
 
     logger.info("API startup complete")
 

backend/api/persona_routes.py

@@ -5,21 +5,24 @@ from __future__ import annotations
 from typing import Dict, List, Optional, Any
 
 from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
-from backend.core.persona_system import PersonaSystem
+from backend.core.persona_system import get_persona_system
+from .storage_service import get_persona_store, refresh_persona_cache
 from .conversation_service import get_conversation_service
+from backend.core.universal_prompts import DEFAULT_PATIENT_SYSTEM_PROMPT, DEFAULT_SURVEYOR_SYSTEM_PROMPT
+from backend.core.analysis_knobs import DEFAULT_ANALYSIS_ATTRIBUTES
 
 router = APIRouter(prefix="", tags=["personas"])
 
-persona_system = PersonaSystem()
+persona_system = get_persona_system()
 
 
 class PersonaResponse(BaseModel):
     id: str
     name: str
     role: str
-    description: str
+    description: str = ""
     is_default: bool = False
 
 
@@ -33,6 +36,38 @@ class PersonaDetailResponse(BaseModel):
     question_bank_items: List[Any] = []
 
 
+class CreatePersonaRequest(BaseModel):
+    kind: str = Field(..., description="surveyor|patient")
+    name: str = Field(..., description="Display name")
+    clone_from_persona_id: Optional[str] = Field(default=None, description="Optional persona id to clone from")
+
+
+class UpdatePersonaRequest(BaseModel):
+    attributes: List[str] = Field(default_factory=list)
+    question_bank_items: List[str] = Field(default_factory=list)
+
+
+class SettingsResponse(BaseModel):
+    surveyor_system_prompt: str
+    patient_system_prompt: str
+    analysis_attributes: List[str]
+
+
+class UpdateSettingsRequest(BaseModel):
+    surveyor_system_prompt: Optional[str] = None
+    patient_system_prompt: Optional[str] = None
+    analysis_attributes: Optional[List[str]] = None
+
+
+@router.get("/settings/defaults")
+async def get_settings_defaults() -> SettingsResponse:
+    return SettingsResponse(
+        surveyor_system_prompt=DEFAULT_SURVEYOR_SYSTEM_PROMPT,
+        patient_system_prompt=DEFAULT_PATIENT_SYSTEM_PROMPT,
+        analysis_attributes=list(DEFAULT_ANALYSIS_ATTRIBUTES),
+    )
+
+
 @router.get("/personas")
 async def list_personas() -> Dict[str, List[PersonaResponse]]:
     try:
@@ -78,20 +113,150 @@ async def api_health() -> Dict[str, str]:
 @router.get("/personas/{persona_id}")
 async def get_persona(persona_id: str) -> PersonaDetailResponse:
     try:
-        persona = persona_system.get_persona(persona_id)
-        if not persona:
+        store = get_persona_store()
+        record = await store.get_persona(persona_id, include_deleted=False)
+        if not record:
             raise HTTPException(status_code=404, detail=f"Persona {persona_id} not found")
-        kind = (persona.get("kind") or persona.get("role") or "").strip().lower() or "unknown"
+        kind = record.kind
         return PersonaDetailResponse(
-            id=persona.get("id", persona_id),
-            name=persona.get("name", "Unknown"),
+            id=record.persona_id,
+            name=record.name,
             kind=kind,
-            description=persona.get("description", "") or "",
-            is_default=bool(persona.get("is_default", False)),
-            attributes=persona.get("attributes") or [],
-            question_bank_items=persona.get("question_bank_items") or [],
+            description="",
+            is_default=record.is_default,
+            attributes=record.attributes,
+            question_bank_items=record.question_bank_items,
         )
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Internal error retrieving persona: {str(e)}")
+
+
+@router.post("/personas")
+async def create_persona(payload: CreatePersonaRequest) -> PersonaDetailResponse:
+    try:
+        kind = (payload.kind or "").strip().lower()
+        if kind not in ("surveyor", "patient"):
+            raise HTTPException(status_code=400, detail="kind must be surveyor|patient")
+        name = (payload.name or "").strip()
+        if not name:
+            raise HTTPException(status_code=400, detail="name is required")
+
+        store = get_persona_store()
+        attributes: List[str] = []
+        question_bank_items: List[str] = []
+        if payload.clone_from_persona_id:
+            src = await store.get_persona(payload.clone_from_persona_id, include_deleted=False)
+            if not src:
+                raise HTTPException(status_code=404, detail="clone_from_persona_id not found")
+            if src.kind != kind:
+                raise HTTPException(status_code=400, detail="clone_from_persona_id kind mismatch")
+            attributes = src.attributes
+            question_bank_items = src.question_bank_items
+
+        persona_id, _ = await store.create_persona(
+            kind=kind,
+            name=name,
+            attributes=attributes,
+            question_bank_items=question_bank_items,
+            is_default=False,
+        )
+        await refresh_persona_cache()
+        record = await store.get_persona(persona_id)
+        if not record:
+            raise HTTPException(status_code=500, detail="Failed to create persona")
+        return PersonaDetailResponse(
+            id=record.persona_id,
+            name=record.name,
+            kind=record.kind,
+            description="",
+            is_default=record.is_default,
+            attributes=record.attributes,
+            question_bank_items=record.question_bank_items,
+        )
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error creating persona: {str(e)}")
+
+
+@router.put("/personas/{persona_id}")
+async def update_persona(persona_id: str, payload: UpdatePersonaRequest) -> PersonaDetailResponse:
+    try:
+        store = get_persona_store()
+        record = await store.get_persona(persona_id, include_deleted=True)
+        if not record:
+            raise HTTPException(status_code=404, detail="persona not found")
+        if record.is_default:
+            raise HTTPException(status_code=403, detail="default persona is immutable")
+
+        await store.update_persona(
+            persona_id=persona_id,
+            name=None,  # name is set on create; not editable in v1
+            attributes=payload.attributes,
+            question_bank_items=payload.question_bank_items,
+            overwrite_defaults=False,
+        )
+        await refresh_persona_cache()
+        updated = await store.get_persona(persona_id)
+        if not updated:
+            raise HTTPException(status_code=404, detail="persona not found")
+        return PersonaDetailResponse(
+            id=updated.persona_id,
+            name=updated.name,
+            kind=updated.kind,
+            description="",
+            is_default=updated.is_default,
+            attributes=updated.attributes,
+            question_bank_items=updated.question_bank_items,
+        )
+    except HTTPException:
+        raise
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error updating persona: {str(e)}")
+
+
+@router.delete("/personas/{persona_id}")
+async def delete_persona(persona_id: str) -> Dict[str, Any]:
+    try:
+        store = get_persona_store()
+        await store.soft_delete_persona(persona_id)
+        await refresh_persona_cache()
+        return {"ok": True}
+    except PermissionError as e:
+        raise HTTPException(status_code=403, detail=str(e))
+    except ValueError:
+        raise HTTPException(status_code=404, detail="persona not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error deleting persona: {str(e)}")
+
+
+@router.get("/settings")
+async def get_settings() -> SettingsResponse:
+    store = get_persona_store()
+    sp = await store.get_setting("surveyor_system_prompt")
+    pp = await store.get_setting("patient_system_prompt")
+    ap = await store.get_setting("analysis_attributes")
+    return SettingsResponse(
+        surveyor_system_prompt=sp if isinstance(sp, str) else "",
+        patient_system_prompt=pp if isinstance(pp, str) else "",
+        analysis_attributes=[s for s in ap if isinstance(ap, str)] if isinstance(ap, list) else [],
+    )
+
+
+@router.put("/settings")
+async def update_settings(payload: UpdateSettingsRequest) -> SettingsResponse:
+    store = get_persona_store()
+    if payload.surveyor_system_prompt is not None:
+        await store.upsert_setting("surveyor_system_prompt", str(payload.surveyor_system_prompt))
+    if payload.patient_system_prompt is not None:
+        await store.upsert_setting("patient_system_prompt", str(payload.patient_system_prompt))
+    if payload.analysis_attributes is not None:
+        await store.upsert_setting(
+            "analysis_attributes",
+            [s.strip() for s in (payload.analysis_attributes or []) if isinstance(s, str) and s.strip()],
+        )
+    return await get_settings()

backend/api/storage_service.py

@@ -4,11 +4,14 @@ import logging
 from typing import Optional
 
 from config.settings import AppSettings, get_settings
-from backend.storage import SQLiteRunStore
+from backend.storage import SQLiteRunStore, SQLitePersonaStore
+from backend.core.persona_seed import seed_defaults_overwrite
+from backend.core.persona_system import get_persona_system
 
 logger = logging.getLogger(__name__)
 
 run_store: Optional[SQLiteRunStore] = None
+persona_store: Optional[SQLitePersonaStore] = None
 
 
 def get_run_store() -> SQLiteRunStore:
@@ -17,11 +20,53 @@ def get_run_store() -> SQLiteRunStore:
     return run_store
 
 
+def get_persona_store() -> SQLitePersonaStore:
+    if persona_store is None:
+        raise RuntimeError("PersonaStore not initialized")
+    return persona_store
+
+
+async def seed_personas_and_settings(*, overwrite_defaults: bool = False) -> None:
+    store = get_persona_store()
+    if overwrite_defaults:
+        await seed_defaults_overwrite(store=store)
+    else:
+        # Best-effort: seed only if missing would require extra checks; keep overwrite behavior explicit.
+        await seed_defaults_overwrite(store=store)
+
+    await refresh_persona_cache()
+
+
+async def refresh_persona_cache() -> None:
+    store = get_persona_store()
+    records = await store.list_persona_records(include_deleted=False)
+    personas: list = []
+    for rec in records:
+        personas.append(
+            {
+                "id": rec.persona_id,
+                "kind": rec.kind,
+                "name": rec.name,
+                "is_default": rec.is_default,
+                "version_id": rec.current_version_id,
+                "attributes": rec.attributes,
+                "question_bank_items": rec.question_bank_items,
+            }
+        )
+    get_persona_system().set_personas(personas)
+
+
 async def initialize_run_store(settings: Optional[AppSettings] = None) -> None:
-    global run_store
+    global run_store, persona_store
     resolved = settings or get_settings()
-    store = SQLiteRunStore(resolved.db.path)
-    await store.init()
-    run_store = store
-    logger.info("RunStore initialized")
+    db_path = resolved.db.path
+
+    rs = SQLiteRunStore(db_path)
+    await rs.init()
+    run_store = rs
+
+    ps = SQLitePersonaStore(db_path)
+    await ps.init()
+    persona_store = ps
 
+    logger.info("RunStore + PersonaStore initialized")

backend/core/conversation_manager.py

@@ -30,7 +30,7 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from backend.core.llm_client import create_llm_client
-from backend.core.persona_system import PersonaSystem
+from backend.core.persona_system import get_persona_system
 from backend.core.surveyor_knobs import compile_surveyor_attributes_overlay, compile_question_bank_overlay
 from backend.core.patient_knobs import compile_patient_attributes_overlay
 from backend.core.universal_prompts import DEFAULT_PATIENT_SYSTEM_PROMPT, DEFAULT_SURVEYOR_SYSTEM_PROMPT
@@ -104,7 +104,7 @@ class ConversationManager:
             llm_parameters: Additional keyword arguments for the LLM client
         """
         # Initialize systems
-        self.persona_system = PersonaSystem()
+        self.persona_system = get_persona_system()
         client_kwargs = {"host": host, "model": model}
         if llm_parameters:
             client_kwargs.update(llm_parameters)

backend/core/default_personas.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import Dict, List
+
+
+DEFAULT_SURVEYOR_PERSONAS: List[Dict] = [
+    {
+        "persona_id": "professional_healthcare_001",
+        "kind": "surveyor",
+        "name": "Dr. Sarah Mitchell",
+        "attributes": [
+            "Senior healthcare survey specialist with 15 years of clinical research experience.",
+            "Professional, warm tone; patient and measured pace.",
+            "Use plain language first; explain medical terms briefly if needed.",
+            "Be empathetic; acknowledge emotions before moving on.",
+            "Ask exactly one question per turn; avoid multi-part questions.",
+            "Avoid giving medical advice; focus on gathering information.",
+            "If the patient seems confused, rephrase the question simply.",
+        ],
+        "question_bank_items": [
+            "Can you tell me about a recent healthcare appointment you had and what it was for?",
+            "Were you able to attend that appointment as planned? If not, what got in the way?",
+            "How easy or difficult was it to get the care you needed (scheduling, transportation, timing)?",
+            "Were your questions answered in a way you could understand?",
+            "Did you feel listened to and respected during the visit?",
+            "What is one thing that would have improved your experience?",
+        ],
+    },
+    {
+        "persona_id": "friendly_researcher_001",
+        "kind": "surveyor",
+        "name": "Alex Thompson",
+        "attributes": [
+            "Clinical research assistant conducting patient experience surveys.",
+            "Warm, approachable, encouraging tone; conversational style.",
+            "Avoid jargon; keep questions short and easy to answer.",
+            "Gently probe for specifics when answers are vague.",
+            "Ask exactly one question per turn; avoid multi-part questions.",
+            "Avoid giving medical advice; focus on listening and clarifying.",
+        ],
+        "question_bank_items": [
+            "What’s been going on with your health recently?",
+            "Can you describe a recent interaction you had with a doctor or clinic?",
+            "Was it easy or hard to get that care (scheduling, travel, cost, timing)?",
+            "Did you feel listened to and understood?",
+            "Were any instructions or next steps clear to you?",
+            "If you could change one thing about that experience, what would it be?",
+        ],
+    },
+    {
+        "persona_id": "professional_healthcare_002",
+        "kind": "surveyor",
+        "name": "Nurse Jordan Lee",
+        "attributes": [
+            "Nurse survey interviewer focused on care coordination and follow-up.",
+            "Efficient and structured while remaining empathetic.",
+            "Summarize briefly to confirm understanding before the next question.",
+            "Ask exactly one question per turn; avoid multi-part questions.",
+            "If the patient mentions a barrier, ask for one concrete example.",
+            "Avoid giving medical advice; focus on experience, access, and process.",
+        ],
+        "question_bank_items": [
+            "What type of care have you needed recently (check-up, follow-up, urgent issue, other)?",
+            "Were you able to get an appointment when you needed it?",
+            "Did anything make it difficult to follow through on care or instructions?",
+            "How well did different parts of your care feel coordinated (calls, referrals, follow-ups)?",
+            "Did you have the support you needed (family, clinic resources, community support)?",
+            "What is one practical change that would make care easier for you?",
+        ],
+    },
+]
+
+
+DEFAULT_PATIENT_PERSONAS: List[Dict] = [
+    {
+        "persona_id": "cooperative_senior_001",
+        "kind": "patient",
+        "name": "Margaret Thompson",
+        "attributes": [
+            "72 years old, retired teacher.",
+            "Managing Type 2 diabetes and high blood pressure for years.",
+            "Friendly and cooperative; wants to help with the survey.",
+            "Sometimes needs medical terms repeated or clarified.",
+            "Tends to give direct answers plus a couple relevant details.",
+            "Worries about health occasionally but is generally doing okay.",
+        ],
+        "question_bank_items": [],
+    },
+    {
+        "persona_id": "anxious_parent_001",
+        "kind": "patient",
+        "name": "Jennifer Chen",
+        "attributes": [
+            "38 years old, working parent.",
+            "Primary concern is a 6-year-old child with recurring asthma.",
+            "Anxious and protective; somewhat skeptical of surveys.",
+            "Often asks why information is needed and how it will be used.",
+            "Can be defensive about care decisions but is not hostile.",
+            "Gives detailed answers when asked about the child's condition.",
+        ],
+        "question_bank_items": [],
+    },
+    {
+        "persona_id": "busy_professional_001",
+        "kind": "patient",
+        "name": "David Rodriguez",
+        "attributes": [
+            "45 years old financial executive with a demanding schedule.",
+            "Work-related stress; irregular sleep.",
+            "Occasional back pain from long sitting.",
+            "Pressed for time; gives brief, direct answers unless prompted.",
+            "Not rude, but can sound impatient; appreciates efficiency.",
+        ],
+        "question_bank_items": [],
+    },
+]
+

backend/core/persona_seed.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from backend.core.default_personas import DEFAULT_PATIENT_PERSONAS, DEFAULT_SURVEYOR_PERSONAS
+from backend.core.universal_prompts import DEFAULT_PATIENT_SYSTEM_PROMPT, DEFAULT_SURVEYOR_SYSTEM_PROMPT
+from backend.core.analysis_knobs import DEFAULT_ANALYSIS_ATTRIBUTES
+from backend.storage.sqlite_persona_store import SQLitePersonaStore
+
+
+async def seed_defaults_overwrite(*, store: SQLitePersonaStore) -> None:
+    # Universal prompts
+    await store.upsert_setting("surveyor_system_prompt", DEFAULT_SURVEYOR_SYSTEM_PROMPT)
+    await store.upsert_setting("patient_system_prompt", DEFAULT_PATIENT_SYSTEM_PROMPT)
+
+    # Analysis agent defaults are managed separately (config UI already supports apply defaults),
+    # but keep a stable key for future shared settings.
+    await store.upsert_setting("analysis_attributes", DEFAULT_ANALYSIS_ATTRIBUTES)
+
+    # Personas (overwrite by writing a new version each startup)
+    for p in (DEFAULT_SURVEYOR_PERSONAS + DEFAULT_PATIENT_PERSONAS):
+        await store.upsert_default_persona(
+            persona_id=p["persona_id"],
+            kind=p["kind"],
+            name=p["name"],
+            attributes=p.get("attributes") or [],
+            question_bank_items=p.get("question_bank_items") or [],
+        )

backend/core/persona_system.py

@@ -22,7 +22,6 @@ Example:
 
 from __future__ import annotations
 
-import yaml
 from typing import Dict, List, Optional, Any, Tuple
 from pathlib import Path
 from datetime import datetime
@@ -119,47 +118,25 @@ class PersonaPromptBuilder:
 class PersonaSystem:
     """Main persona management system."""
     
-    def __init__(self, personas_dir: Optional[Path] = None):
-        """Initialize persona system.
-        
-        Args:
-            personas_dir: Directory containing persona YAML files
+    def __init__(self):
+        """Initialize persona system (cache-only).
+
+        Personas are loaded from the DB-backed persona store during app startup.
         """
-        if personas_dir is None:
-            # Default to data directory
-            personas_dir = Path(__file__).parent.parent.parent / "data"
-            
-        self.personas_dir = Path(personas_dir)
         self.personas: Dict[str, Dict[str, Any]] = {}
         self.prompt_builder = PersonaPromptBuilder()
-        
-        # Load personas
-        self._load_personas()
-        
-    def _load_personas(self):
-        """Load all persona definitions from YAML files."""
-        if not self.personas_dir.exists():
-            logger.warning(f"Personas directory not found: {self.personas_dir}")
-            return
-            
-        for yaml_file in self.personas_dir.glob("*.yaml"):
-            try:
-                with open(yaml_file, 'r') as f:
-                    data = yaml.safe_load(f)
-                    
-                if "personas" in data:
-                    for persona in data["personas"]:
-                        persona_id = persona.get("id")
-                        if persona_id:
-                            self.personas[persona_id] = persona
-                            logger.info(f"Loaded persona: {persona_id}")
-                        else:
-                            logger.warning(f"Persona missing ID in {yaml_file}")
-                            
-            except Exception as e:
-                logger.error(f"Failed to load personas from {yaml_file}: {e}")
-                
-        logger.info(f"Loaded {len(self.personas)} personas total")
+
+    def set_personas(self, personas: List[Dict[str, Any]]) -> None:
+        """Replace the in-memory persona cache with the provided records."""
+        cache: Dict[str, Dict[str, Any]] = {}
+        for persona in personas or []:
+            if not isinstance(persona, dict):
+                continue
+            pid = persona.get("id")
+            if isinstance(pid, str) and pid.strip():
+                cache[pid] = persona
+        self.personas = cache
+        logger.info(f"Persona cache updated: {len(self.personas)} personas")
         
     def get_persona(self, persona_id: str) -> Optional[Dict[str, Any]]:
         """Get persona by ID.
@@ -327,10 +304,8 @@ class PersonaSystem:
             return 1.0  # Default delay
             
     def reload_personas(self):
-        """Reload persona definitions from files."""
-        self.personas.clear()
-        self._load_personas()
-        logger.info("Personas reloaded")
+        """Deprecated: runtime personas are loaded from DB-backed store on startup."""
+        logger.info("reload_personas() is a no-op; personas are DB-backed")
 
 
 # Global persona system instance

backend/storage/__init__.py

@@ -1,5 +1,12 @@
-from .models import RunRecord, RunSummary
+from .models import RunRecord, RunSummary, PersonaRecord, PersonaSummary
+from .sqlite_persona_store import SQLitePersonaStore
 from .sqlite_run_store import SQLiteRunStore
 
-__all__ = ["RunRecord", "RunSummary", "SQLiteRunStore"]
-
+__all__ = [
+    "RunRecord",
+    "RunSummary",
+    "PersonaRecord",
+    "PersonaSummary",
+    "SQLiteRunStore",
+    "SQLitePersonaStore",
+]

backend/storage/models.py

@@ -30,3 +30,25 @@ class RunRecord:
     title: Optional[str] = None
     input_summary: Optional[str] = None
 
+
+@dataclass(frozen=True)
+class PersonaSummary:
+    persona_id: str
+    kind: str
+    name: str
+    is_default: bool = False
+    is_deleted: bool = False
+
+
+@dataclass(frozen=True)
+class PersonaRecord:
+    persona_id: str
+    kind: str
+    name: str
+    is_default: bool
+    is_deleted: bool
+    current_version_id: str
+    created_at: str
+    updated_at: str
+    attributes: List[str]
+    question_bank_items: List[str]

backend/storage/sqlite_persona_store.py

@@ -0,0 +1,441 @@
+from __future__ import annotations
+
+import json
+from dataclasses import asdict
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+from uuid import uuid4
+
+import aiosqlite
+
+from .models import PersonaRecord, PersonaSummary
+
+
+def _now_iso() -> str:
+    return datetime.now().isoformat()
+
+
+def _clean_str_list(value: Any) -> List[str]:
+    if not isinstance(value, list):
+        return []
+    out: List[str] = []
+    for item in value:
+        if isinstance(item, str) and item.strip():
+            out.append(item.strip())
+    return out
+
+
+class SQLitePersonaStore:
+    def __init__(self, db_path: str):
+        self.db_path = str(db_path)
+
+    async def init(self) -> None:
+        Path(self.db_path).expanduser().resolve().parent.mkdir(parents=True, exist_ok=True)
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+
+            await db.execute(
+                """
+                CREATE TABLE IF NOT EXISTS personas (
+                    persona_id TEXT PRIMARY KEY,
+                    kind TEXT NOT NULL,
+                    name TEXT NOT NULL,
+                    is_default INTEGER NOT NULL DEFAULT 0,
+                    is_deleted INTEGER NOT NULL DEFAULT 0,
+                    current_version_id TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+                """
+            )
+            await db.execute(
+                "CREATE INDEX IF NOT EXISTS personas_kind ON personas(kind);"
+            )
+            await db.execute(
+                "CREATE INDEX IF NOT EXISTS personas_is_default ON personas(is_default);"
+            )
+            await db.execute(
+                """
+                CREATE TABLE IF NOT EXISTS persona_versions (
+                    persona_id TEXT NOT NULL,
+                    version_id TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    content_json TEXT NOT NULL,
+                    PRIMARY KEY (persona_id, version_id),
+                    FOREIGN KEY (persona_id) REFERENCES personas(persona_id) ON DELETE CASCADE
+                );
+                """
+            )
+            await db.execute(
+                """
+                CREATE TABLE IF NOT EXISTS app_settings (
+                    key TEXT PRIMARY KEY,
+                    value_json TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+                """
+            )
+            await db.commit()
+
+    async def upsert_setting(self, key: str, value: Any) -> None:
+        if not isinstance(key, str) or not key.strip():
+            raise ValueError("key is required")
+        updated_at = _now_iso()
+        payload = json.dumps(value, ensure_ascii=False)
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            await db.execute(
+                """
+                INSERT INTO app_settings (key, value_json, updated_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(key) DO UPDATE SET
+                    value_json=excluded.value_json,
+                    updated_at=excluded.updated_at;
+                """,
+                (key, payload, updated_at),
+            )
+            await db.commit()
+
+    async def get_setting(self, key: str) -> Optional[Any]:
+        if not isinstance(key, str) or not key.strip():
+            return None
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            cur = await db.execute(
+                "SELECT value_json FROM app_settings WHERE key = ?;",
+                (key,),
+            )
+            row = await cur.fetchone()
+            if not row:
+                return None
+            try:
+                return json.loads(row[0])
+            except Exception:
+                return None
+
+    async def list_personas(
+        self,
+        *,
+        kind: Optional[str] = None,
+        include_deleted: bool = False,
+    ) -> List[PersonaSummary]:
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            where: List[str] = []
+            args: List[Any] = []
+            if kind:
+                where.append("kind = ?")
+                args.append(kind)
+            if not include_deleted:
+                where.append("is_deleted = 0")
+            clause = ("WHERE " + " AND ".join(where)) if where else ""
+            cur = await db.execute(
+                f"""
+                SELECT persona_id, kind, name, is_default, is_deleted
+                FROM personas
+                {clause}
+                ORDER BY is_default DESC, name ASC;
+                """,
+                tuple(args),
+            )
+            rows = await cur.fetchall()
+        return [
+            PersonaSummary(
+                persona_id=row[0],
+                kind=row[1],
+                name=row[2],
+                is_default=bool(row[3]),
+                is_deleted=bool(row[4]),
+            )
+            for row in rows
+        ]
+
+    async def list_persona_records(
+        self,
+        *,
+        kind: Optional[str] = None,
+        include_deleted: bool = False,
+    ) -> List[PersonaRecord]:
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            where: List[str] = []
+            args: List[Any] = []
+            if kind:
+                where.append("p.kind = ?")
+                args.append(kind)
+            if not include_deleted:
+                where.append("p.is_deleted = 0")
+            clause = ("WHERE " + " AND ".join(where)) if where else ""
+            cur = await db.execute(
+                f"""
+                SELECT
+                    p.persona_id, p.kind, p.name, p.is_default, p.is_deleted,
+                    p.current_version_id, p.created_at, p.updated_at,
+                    v.content_json
+                FROM personas p
+                JOIN persona_versions v
+                  ON v.persona_id = p.persona_id AND v.version_id = p.current_version_id
+                {clause}
+                ORDER BY p.is_default DESC, p.name ASC;
+                """,
+                tuple(args),
+            )
+            rows = await cur.fetchall()
+
+        out: List[PersonaRecord] = []
+        for row in rows:
+            content: Dict[str, Any] = {}
+            if isinstance(row[8], str):
+                try:
+                    content = json.loads(row[8]) or {}
+                except Exception:
+                    content = {}
+            out.append(
+                PersonaRecord(
+                    persona_id=row[0],
+                    kind=row[1],
+                    name=row[2],
+                    is_default=bool(row[3]),
+                    is_deleted=bool(row[4]),
+                    current_version_id=row[5],
+                    created_at=row[6],
+                    updated_at=row[7],
+                    attributes=_clean_str_list(content.get("attributes")),
+                    question_bank_items=_clean_str_list(content.get("question_bank_items")),
+                )
+            )
+        return out
+
+    async def get_persona(self, persona_id: str, *, include_deleted: bool = False) -> Optional[PersonaRecord]:
+        if not isinstance(persona_id, str) or not persona_id.strip():
+            return None
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            cur = await db.execute(
+                """
+                SELECT persona_id, kind, name, is_default, is_deleted, current_version_id, created_at, updated_at
+                FROM personas
+                WHERE persona_id = ?;
+                """,
+                (persona_id,),
+            )
+            row = await cur.fetchone()
+            if not row:
+                return None
+            if (not include_deleted) and bool(row[4]):
+                return None
+            current_version_id = row[5]
+            cur = await db.execute(
+                """
+                SELECT content_json
+                FROM persona_versions
+                WHERE persona_id = ? AND version_id = ?;
+                """,
+                (persona_id, current_version_id),
+            )
+            vrow = await cur.fetchone()
+            content: Dict[str, Any] = {}
+            if vrow and isinstance(vrow[0], str):
+                try:
+                    content = json.loads(vrow[0]) or {}
+                except Exception:
+                    content = {}
+        attrs = _clean_str_list(content.get("attributes"))
+        qb = _clean_str_list(content.get("question_bank_items"))
+        return PersonaRecord(
+            persona_id=row[0],
+            kind=row[1],
+            name=row[2],
+            is_default=bool(row[3]),
+            is_deleted=bool(row[4]),
+            current_version_id=row[5],
+            created_at=row[6],
+            updated_at=row[7],
+            attributes=attrs,
+            question_bank_items=qb,
+        )
+
+    async def create_persona(
+        self,
+        *,
+        persona_id: Optional[str] = None,
+        kind: str,
+        name: str,
+        attributes: Optional[List[str]] = None,
+        question_bank_items: Optional[List[str]] = None,
+        is_default: bool = False,
+    ) -> Tuple[str, str]:
+        if kind not in ("surveyor", "patient"):
+            raise ValueError("kind must be 'surveyor' or 'patient'")
+        if not isinstance(name, str) or not name.strip():
+            raise ValueError("name is required")
+        if persona_id is not None:
+            if not isinstance(persona_id, str) or not persona_id.strip():
+                raise ValueError("persona_id must be a non-empty string when provided")
+            persona_id = persona_id.strip()
+        else:
+            persona_id = str(uuid4())
+        version_id = str(uuid4())
+        created_at = _now_iso()
+        updated_at = created_at
+        content = {
+            "attributes": _clean_str_list(attributes),
+            "question_bank_items": _clean_str_list(question_bank_items) if kind == "surveyor" else [],
+        }
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            await db.execute("BEGIN;")
+            try:
+                await db.execute(
+                    """
+                    INSERT INTO personas (
+                        persona_id, kind, name, is_default, is_deleted, current_version_id, created_at, updated_at
+                    ) VALUES (?, ?, ?, ?, 0, ?, ?, ?);
+                    """,
+                    (persona_id, kind, name.strip(), 1 if is_default else 0, version_id, created_at, updated_at),
+                )
+                await db.execute(
+                    """
+                    INSERT INTO persona_versions (persona_id, version_id, created_at, content_json)
+                    VALUES (?, ?, ?, ?);
+                    """,
+                    (persona_id, version_id, created_at, json.dumps(content, ensure_ascii=False)),
+                )
+                await db.commit()
+            except Exception:
+                await db.execute("ROLLBACK;")
+                raise
+        return persona_id, version_id
+
+    async def upsert_default_persona(
+        self,
+        *,
+        persona_id: str,
+        kind: str,
+        name: str,
+        attributes: List[str],
+        question_bank_items: List[str],
+    ) -> str:
+        if kind not in ("surveyor", "patient"):
+            raise ValueError("kind must be 'surveyor' or 'patient'")
+        if not isinstance(persona_id, str) or not persona_id.strip():
+            raise ValueError("persona_id is required")
+        if not isinstance(name, str) or not name.strip():
+            raise ValueError("name is required")
+
+        persona_id = persona_id.strip()
+        version_id = str(uuid4())
+        now = _now_iso()
+        content = {
+            "attributes": _clean_str_list(attributes),
+            "question_bank_items": _clean_str_list(question_bank_items) if kind == "surveyor" else [],
+        }
+
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            await db.execute("BEGIN;")
+            try:
+                cur = await db.execute(
+                    "SELECT persona_id FROM personas WHERE persona_id = ?;",
+                    (persona_id,),
+                )
+                row = await cur.fetchone()
+                if row:
+                    await db.execute(
+                        """
+                        INSERT INTO persona_versions (persona_id, version_id, created_at, content_json)
+                        VALUES (?, ?, ?, ?);
+                        """,
+                        (persona_id, version_id, now, json.dumps(content, ensure_ascii=False)),
+                    )
+                    await db.execute(
+                        """
+                        UPDATE personas
+                        SET kind = ?, name = ?, is_default = 1, is_deleted = 0, current_version_id = ?, updated_at = ?
+                        WHERE persona_id = ?;
+                        """,
+                        (kind, name.strip(), version_id, now, persona_id),
+                    )
+                else:
+                    await db.execute(
+                        """
+                        INSERT INTO personas (
+                            persona_id, kind, name, is_default, is_deleted, current_version_id, created_at, updated_at
+                        ) VALUES (?, ?, ?, 1, 0, ?, ?, ?);
+                        """,
+                        (persona_id, kind, name.strip(), version_id, now, now),
+                    )
+                    await db.execute(
+                        """
+                        INSERT INTO persona_versions (persona_id, version_id, created_at, content_json)
+                        VALUES (?, ?, ?, ?);
+                        """,
+                        (persona_id, version_id, now, json.dumps(content, ensure_ascii=False)),
+                    )
+                await db.commit()
+            except Exception:
+                await db.execute("ROLLBACK;")
+                raise
+        return version_id
+
+    async def update_persona(
+        self,
+        *,
+        persona_id: str,
+        name: Optional[str] = None,
+        attributes: Optional[List[str]] = None,
+        question_bank_items: Optional[List[str]] = None,
+        overwrite_defaults: bool = False,
+    ) -> str:
+        record = await self.get_persona(persona_id, include_deleted=True)
+        if not record:
+            raise ValueError("persona not found")
+        if record.is_default and not overwrite_defaults:
+            raise PermissionError("default persona is immutable")
+        version_id = str(uuid4())
+        created_at = _now_iso()
+        updated_at = created_at
+        next_name = (name.strip() if isinstance(name, str) and name.strip() else record.name)
+        content = {
+            "attributes": _clean_str_list(attributes) if attributes is not None else record.attributes,
+            "question_bank_items": _clean_str_list(question_bank_items) if record.kind == "surveyor" and question_bank_items is not None else record.question_bank_items,
+        }
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            await db.execute("BEGIN;")
+            try:
+                await db.execute(
+                    """
+                    INSERT INTO persona_versions (persona_id, version_id, created_at, content_json)
+                    VALUES (?, ?, ?, ?);
+                    """,
+                    (persona_id, version_id, created_at, json.dumps(content, ensure_ascii=False)),
+                )
+                await db.execute(
+                    """
+                    UPDATE personas
+                    SET name = ?, current_version_id = ?, updated_at = ?, is_deleted = 0
+                    WHERE persona_id = ?;
+                    """,
+                    (next_name, version_id, updated_at, persona_id),
+                )
+                await db.commit()
+            except Exception:
+                await db.execute("ROLLBACK;")
+                raise
+        return version_id
+
+    async def soft_delete_persona(self, persona_id: str) -> None:
+        record = await self.get_persona(persona_id, include_deleted=True)
+        if not record:
+            raise ValueError("persona not found")
+        if record.is_default:
+            raise PermissionError("default persona is immutable")
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("PRAGMA foreign_keys=ON;")
+            await db.execute(
+                "UPDATE personas SET is_deleted = 1, updated_at = ? WHERE persona_id = ?;",
+                (_now_iso(), persona_id),
+            )
+            await db.commit()

data/patient_personas.yaml

@@ -1,48 +0,0 @@
-# Default Patient Personas (v2: attributes-only)
-#
-# These are immutable baseline personas shipped with the app.
-# Persona behavior is defined by:
-# - a universal patient system prompt (type-wide)
-# - persona-specific attributes
-#
-# No persona-specific system_prompt exists in v2 defaults.
-
-personas:
-  - id: "cooperative_senior_001"
-    kind: "patient"
-    is_default: true
-    name: "Margaret Thompson"
-    description: "Friendly senior; cooperative; sometimes needs clarification."
-    attributes:
-      - "72 years old, retired teacher."
-      - "Managing Type 2 diabetes and high blood pressure for years."
-      - "Friendly and cooperative; wants to help with the survey."
-      - "Sometimes needs medical terms repeated or clarified."
-      - "Tends to give direct answers plus a couple relevant details."
-      - "Worries about health occasionally but is generally doing okay."
-
-  - id: "anxious_parent_001"
-    kind: "patient"
-    is_default: true
-    name: "Jennifer Chen"
-    description: "Anxious parent; detail-seeking; skeptical but not hostile."
-    attributes:
-      - "38 years old, working parent."
-      - "Primary concern is a 6-year-old child with recurring asthma."
-      - "Anxious and protective; somewhat skeptical of surveys."
-      - "Often asks why information is needed and how it will be used."
-      - "Can be defensive about care decisions but is not hostile."
-      - "Gives detailed answers when asked about the child's condition."
-
-  - id: "busy_professional_001"
-    kind: "patient"
-    is_default: true
-    name: "David Rodriguez"
-    description: "Busy professional; brief answers; time-conscious."
-    attributes:
-      - "45 years old financial executive with a demanding schedule."
-      - "Work-related stress; irregular sleep."
-      - "Occasional back pain from long sitting."
-      - "Pressed for time; gives brief, direct answers unless prompted."
-      - "Not rude, but can sound impatient; appreciates efficiency."
-

data/surveyor_personas.yaml

@@ -1,70 +0,0 @@
-# Default Surveyor Personas (v2: attributes-only)
-#
-# These are immutable baseline personas shipped with the app.
-# Persona behavior is defined by:
-# - a universal surveyor system prompt (type-wide)
-# - persona-specific attributes (+ optional question bank)
-#
-# No persona-specific system_prompt exists in v2 defaults.
-
-personas:
-  - id: "professional_healthcare_001"
-    kind: "surveyor"
-    is_default: true
-    name: "Dr. Sarah Mitchell"
-    description: "Professional, warm, clinically fluent."
-    attributes:
-      - "Senior healthcare survey specialist with 15 years of clinical research experience."
-      - "Professional, warm tone; patient and measured pace."
-      - "Use plain language first; explain medical terms briefly if needed."
-      - "Be empathetic; acknowledge emotions before moving on."
-      - "Ask exactly one question per turn; avoid multi-part questions."
-      - "Avoid giving medical advice; focus on gathering information."
-      - "If the patient seems confused, rephrase the question simply."
-    question_bank_items:
-      - "Can you tell me about a recent healthcare appointment you had and what it was for?"
-      - "Were you able to attend that appointment as planned? If not, what got in the way?"
-      - "How easy or difficult was it to get the care you needed (scheduling, transportation, timing)?"
-      - "Were your questions answered in a way you could understand?"
-      - "Did you feel listened to and respected during the visit?"
-      - "What is one thing that would have improved your experience?"
-
-  - id: "friendly_researcher_001"
-    kind: "surveyor"
-    is_default: true
-    name: "Alex Thompson"
-    description: "Friendly, encouraging, plain-language interviewer."
-    attributes:
-      - "Clinical research assistant conducting patient experience surveys."
-      - "Warm, approachable, encouraging tone; conversational style."
-      - "Avoid jargon; keep questions short and easy to answer."
-      - "Gently probe for specifics when answers are vague."
-      - "Ask exactly one question per turn; avoid multi-part questions."
-      - "Avoid giving medical advice; focus on listening and clarifying."
-    question_bank_items:
-      - "What’s been going on with your health recently?"
-      - "Can you describe a recent interaction you had with a doctor or clinic?"
-      - "Was it easy or hard to get that care (scheduling, travel, cost, timing)?"
-      - "Did you feel listened to and understood?"
-      - "Were any instructions or next steps clear to you?"
-      - "If you could change one thing about that experience, what would it be?"
-
-  - id: "professional_healthcare_002"
-    kind: "surveyor"
-    is_default: true
-    name: "Nurse Jordan Lee"
-    description: "Efficient, structured, empathetic."
-    attributes:
-      - "Nurse survey interviewer focused on care coordination and follow-up."
-      - "Efficient and structured while remaining empathetic."
-      - "Summarize briefly to confirm understanding before the next question."
-      - "Ask exactly one question per turn; avoid multi-part questions."
-      - "If the patient mentions a barrier, ask for one concrete example."
-      - "Avoid giving medical advice; focus on experience, access, and process."
-    question_bank_items:
-      - "What type of care have you needed recently (check-up, follow-up, urgent issue, other)?"
-      - "Were you able to get an appointment when you needed it?"
-      - "Did anything make it difficult to follow through on care or instructions?"
-      - "How well did different parts of your care feel coordinated (calls, referrals, follow-ups)?"
-      - "Did you have the support you needed (family, clinic resources, community support)?"
-      - "What is one practical change that would make care easier for you?"

docs/development.md

@@ -64,7 +64,6 @@ The UI includes a **Configuration** view used to edit persona-specific settings
 
 ## Making Changes Safely
 
-- Prefer editing personas via YAML (`data/`) and restart the backend to reload.
 - All configuration flows through `config/settings.py`; add new settings there and reference them via `get_settings()`.
 - When adding LLM providers, implement a new client in `backend/core/llm_client.py` and hook it into the existing factory.
 - Keep WebSocket message schemas stable (`backend/api/conversation_ws.py`); update both backend and frontend consumers if you change them.
@@ -74,8 +73,7 @@ The UI includes a **Configuration** view used to edit persona-specific settings
 - No automated test suite yet. Add lightweight `pytest` modules under `tests/` as you extend functionality.
 - Manually verify through the primary web UI (`frontend/react_gradio_hybrid.py`).
 - For persistence + history: complete a run, confirm it appears in **History**, restart the container, and confirm it still appears and exports download.
-- For surveyor configuration: edit **Surveyors → Attributes** and/or **Question bank** in **Configuration** (for a given surveyor persona), then select that surveyor persona in **AI-to-AI** and run a session. Confirm the completed run’s `config.personas.surveyor_attributes` and `config.personas.surveyor_question_bank` are present in `/api/runs/{run_id}`.
-- For question bank (surveyor): after selecting a surveyor persona that has a question bank configured, complete a run and confirm the surveyor sticks to one bank question per turn and the run’s `config.personas.asked_question_ids` is populated in `/api/runs/{run_id}`.
+- For persona config: edit the shared system prompt and/or a user persona in **Configuration**, click **Save**, and confirm the change is reflected in subsequent runs.
 - If you need to debug the conversation loop, instrument `backend/core/conversation_manager.py` or launch a shell and run it directly.
 
 ## Notes on Persistence (HF)

docs/overview.md

@@ -19,8 +19,9 @@ The AI Survey Simulator orchestrates AI-to-AI healthcare survey conversations so
 - **LLM Backend (Ollama by default)**  
   The backend uses `LLM_HOST`/`LLM_MODEL` from `.env` to reach a local Ollama server. Other providers can be integrated by extending `llm_client.py`.
 
-- **Data Assets (`data/`)**  
-  Persona definitions live in YAML files (`patient_personas.yaml`, `surveyor_personas.yaml`). Update these to add or refine personas.
+- **Persistence (`DB_PATH`)**  
+  Sealed runs and app-wide configuration (personas + shared prompts/settings) are stored in SQLite at `DB_PATH` (recommended on HF: under `/data`).
+  Default personas are seeded on startup.
 
 ## Runtime Flow
 
@@ -53,10 +54,10 @@ These are forwarded across the `/ws/frontend/...` bridge to the backend socket.
 
 The UI includes a **Configuration** view (same page, no reload) that lets you:
 
-- Select surveyor + patient personas (loaded from `GET /api/personas`)
-- Add optional prompt additions for each role (sent with `start_conversation`)
+- Edit app-wide surveyor/patient system prompts and analysis attributes (`GET/PUT /api/settings`)
+- Create/edit/delete user personas (`GET/POST/PUT/DELETE /api/personas`)
 
-These settings are currently stored in the browser (local-only) and apply to the next run.
+Persona selection for actually running conversations is done in the **AI-to-AI** and **Human-to-AI** panels.
 
 ## Export & Persistence Notes
 
@@ -93,9 +94,6 @@ frontend/
   gradio_app.py          # legacy/optional local UI
   react_gradio_hybrid.py # primary demo UI (web)
   websocket_manager.py
-data/
-  patient_personas.yaml
-  surveyor_personas.yaml
 config/
   settings.py            # Shared configuration loader
 .env.example

docs/persistence.md

@@ -278,16 +278,16 @@ End-of-analysis save flow:
 
 ### Personas
 
-- `GET /api/personas` (already exists for current YAML personas; will evolve to use DB + defaults)
+- `GET /api/personas`
 - `POST /api/personas`
 - `PUT /api/personas/{persona_id}` (creates a new version)
 - `DELETE /api/personas/{persona_id}` (soft delete)
 - (optional) `GET /api/personas/{persona_id}/versions`
 
-Important: keep existing YAML personas as “defaults”:
+Defaults:
 
-- On first run, load YAML defaults if DB is empty (or treat YAML as seed data).
-- DB becomes the writable source; YAML remains the baseline defaults.
+- Default personas are seeded by the backend on startup.
+- The DB is the runtime source of truth for both defaults and user-created personas.
 
 ---
 

docs/persona-knobs.md

@@ -1,4 +1,4 @@
-# Persona Controls (v2) — Surveyor + Patient (local-first)
+# Persona Controls (v2) — Surveyor + Patient
 
 This document defines the **core, behavior-changing configuration controls** we support for personas.
 
@@ -14,7 +14,7 @@ The guiding principle is: **every UI control must have a guaranteed effect** on
 
 ## Key design decision: compile attributes + question bank into prompts
 
-Today, behavior is primarily driven by the persona’s `system_prompt`. Many YAML fields do not materially affect generation unless they are duplicated into that prompt.
+Today, behavior is primarily driven by the persona’s system prompt. Many structured fields do not materially affect generation unless they are duplicated into that prompt.
 
 For v2, we:
 
@@ -22,7 +22,7 @@ For v2, we:
 2. Let the user define a **Question bank** the surveyor must work through.
 3. **Compile** both into a deterministic prompt overlay included in the surveyor system prompt, so the controls always matter.
 
-Non-goal: making every YAML field first-class in the UI.
+Non-goal: making every structured field first-class in the UI.
 
 ---
 
@@ -43,7 +43,6 @@ Personas can express style *within* these constraints, but do not change the con
 
 ### Identity
 - `name` (required): display name.
-- `description` (optional): short one-liner shown in selectors.
 
 ### Attributes (plain bullet lines)
 A list of short, testable rules, for example:
@@ -64,7 +63,6 @@ Patient structured controls are intentionally minimal for now; the synthetic pat
 
 ### Identity
 - `name` (required): display name.
-- `description` (optional): short one-liner shown in selectors.
 
 ### Attributes (plain bullet lines)
 A list of short rules the patient should follow during the session, compiled into the patient prompt so the control always matters.

docs/roadmap.md

@@ -10,7 +10,7 @@ _Last updated: 2026-01-22_
   - Bottom-up findings (emergent themes)
   - Top-down coding (care experience rubric + codebook categories)
 - FastAPI backend with conversation management service
-- Personas defined via YAML and loaded dynamically
+- Personas persisted in DB (seeded defaults + user-created)
 - Ollama integration with fallback to `/api/generate`
 - Hosted LLM support via OpenRouter (`LLM_BACKEND=openrouter`)
 - Hugging Face Spaces (Docker) deployment

frontend/pages/config_view.py

@@ -51,30 +51,50 @@ You will also be given persona-specific attributes.`;
 		            const [surveyorQuestionItems, setSurveyorQuestionItems] = React.useState([]);
 		            const [surveyorAttributeItems, setSurveyorAttributeItems] = React.useState([]);
 		            const [patientAttributeItems, setPatientAttributeItems] = React.useState([]);
-		            const [surveyorSystemPrompt, setSurveyorSystemPrompt] = React.useState(() => {
-		                const store = (existing && existing.system_prompts && typeof existing.system_prompts === 'object') ? existing.system_prompts : {};
-		                return (typeof store.surveyor === 'string') ? store.surveyor : '';
+            const [surveyorSystemPrompt, setSurveyorSystemPrompt] = React.useState(() => {
+		                return '';
 		            });
 		            const [patientSystemPrompt, setPatientSystemPrompt] = React.useState(() => {
-		                const store = (existing && existing.system_prompts && typeof existing.system_prompts === 'object') ? existing.system_prompts : {};
-		                return (typeof store.patient === 'string') ? store.patient : '';
+		                return '';
 		            });
 		            const [surveyorPersonaDetail, setSurveyorPersonaDetail] = React.useState(null);
 		            const [patientPersonaDetail, setPatientPersonaDetail] = React.useState(null);
 		            const [analysisAttributeItems, setAnalysisAttributeItems] = React.useState(() => {
-		                const store = (existing && existing.analysis_agent && typeof existing.analysis_agent === 'object') ? existing.analysis_agent : {};
-		                const attrs = Array.isArray(store.attributes) ? store.attributes : null;
-		                if (attrs && attrs.length) {
-		                    return attrs
-		                        .map((x) => (typeof x === 'string' ? x.trim() : ''))
-		                        .filter((x) => x.length > 0);
-		                }
 		                return [];
 		            });
 		            const [savedAt, setSavedAt] = React.useState(existing?.saved_at || null);
 		            const [saveFlash, setSaveFlash] = React.useState(false);
-		            const applySurveyorDefaults = () => setSurveyorSystemPrompt(DEFAULT_SURVEYOR_SYSTEM_PROMPT);
-		            const applyPatientDefaults = () => setPatientSystemPrompt(DEFAULT_PATIENT_SYSTEM_PROMPT);
+		            const applySurveyorDefaults = () => {
+		                authedFetch('/api/settings/defaults')
+		                    .then(r => r.json())
+		                    .then(data => {
+		                        if (typeof data?.surveyor_system_prompt === 'string') setSurveyorSystemPrompt(data.surveyor_system_prompt);
+		                        else setSurveyorSystemPrompt(DEFAULT_SURVEYOR_SYSTEM_PROMPT);
+		                    })
+		                    .catch(() => setSurveyorSystemPrompt(DEFAULT_SURVEYOR_SYSTEM_PROMPT));
+		            };
+		            const applyPatientDefaults = () => {
+		                authedFetch('/api/settings/defaults')
+		                    .then(r => r.json())
+		                    .then(data => {
+		                        if (typeof data?.patient_system_prompt === 'string') setPatientSystemPrompt(data.patient_system_prompt);
+		                        else setPatientSystemPrompt(DEFAULT_PATIENT_SYSTEM_PROMPT);
+		                    })
+		                    .catch(() => setPatientSystemPrompt(DEFAULT_PATIENT_SYSTEM_PROMPT));
+		            };
+
+		            const refreshPersonas = () => {
+		                return authedFetch('/api/personas')
+		                    .then(r => r.json())
+		                    .then(data => {
+		                        setPersonas({
+		                            surveyors: data.surveyors || [],
+		                            patients: data.patients || []
+		                        });
+		                        return data;
+		                    })
+		                    .catch(() => null);
+		            };
 
 	            const addAnalysisAttribute = () => {
 	                setAnalysisAttributeItems((prev) => ([...(prev || []), '' ]));
@@ -89,8 +109,33 @@ You will also be given persona-specific attributes.`;
 	            };
 
 	            const applyAnalysisDefaults = () => {
-	                setAnalysisAttributeItems([...(ANALYSIS_DEFAULT_ATTRIBUTES || [])]);
+	                authedFetch('/api/settings/defaults')
+	                    .then(r => r.json())
+	                    .then(data => {
+	                        const attrs = Array.isArray(data?.analysis_attributes) ? data.analysis_attributes : [];
+	                        const cleaned = attrs.map((x) => (typeof x === 'string' ? x.trim() : '')).filter((x) => x.length > 0);
+	                        if (cleaned.length > 0) setAnalysisAttributeItems(cleaned);
+	                        else setAnalysisAttributeItems([...(ANALYSIS_DEFAULT_ATTRIBUTES || [])]);
+	                    })
+	                    .catch(() => setAnalysisAttributeItems([...(ANALYSIS_DEFAULT_ATTRIBUTES || [])]));
+	            };
+
+	            const addSurveyorAttribute = () => setSurveyorAttributeItems((prev) => ([...(prev || []), '' ]));
+	            const updateSurveyorAttribute = (idx, text) => setSurveyorAttributeItems((prev) => (prev || []).map((v, i) => (i === idx ? text : v)));
+	            const removeSurveyorAttribute = (idx) => setSurveyorAttributeItems((prev) => (prev || []).filter((_, i) => i !== idx));
+
+	            const addSurveyorQuestion = () => {
+	                const nextId = `q${String((surveyorQuestionItems || []).length + 1).padStart(2, '0')}`;
+	                setSurveyorQuestionItems((prev) => ([...(prev || []), { id: nextId, text: '' }]));
+	            };
+	            const updateSurveyorQuestionText = (id, text) => {
+	                setSurveyorQuestionItems((prev) => (prev || []).map((q) => (q.id === id ? Object.assign({}, q, { text }) : q)));
 	            };
+	            const removeSurveyorQuestion = (id) => setSurveyorQuestionItems((prev) => (prev || []).filter((q) => q.id !== id));
+
+	            const addPatientAttribute = () => setPatientAttributeItems((prev) => ([...(prev || []), '' ]));
+	            const updatePatientAttribute = (idx, text) => setPatientAttributeItems((prev) => (prev || []).map((v, i) => (i === idx ? text : v)));
+	            const removePatientAttribute = (idx) => setPatientAttributeItems((prev) => (prev || []).filter((_, i) => i !== idx));
 
             React.useEffect(() => {
                 authedFetch('/api/personas')
@@ -104,6 +149,18 @@ You will also be given persona-specific attributes.`;
                     .catch(() => {});
             }, []);
 
+	            React.useEffect(() => {
+	                authedFetch('/api/settings')
+	                    .then(r => r.json())
+	                    .then(data => {
+	                        if (typeof data?.surveyor_system_prompt === 'string') setSurveyorSystemPrompt(data.surveyor_system_prompt);
+	                        if (typeof data?.patient_system_prompt === 'string') setPatientSystemPrompt(data.patient_system_prompt);
+	                        const attrs = Array.isArray(data?.analysis_attributes) ? data.analysis_attributes : [];
+	                        setAnalysisAttributeItems(attrs.map((x) => (typeof x === 'string' ? x.trim() : '')).filter((x) => x.length > 0));
+	                    })
+	                    .catch(() => {});
+	            }, []);
+
 	            React.useEffect(() => {
 	                authedFetch(`/api/personas/${selectedSurveyorId}`)
 	                    .then(r => r.json())
@@ -140,27 +197,84 @@ You will also be given persona-specific attributes.`;
 
 		            const onSave = () => {
 		                const prev = loadConfig() || {};
-
 		                const cfg = Object.assign({}, prev, {
 		                    editor: {
 		                        surveyor_persona_id: selectedSurveyorId,
 		                        patient_persona_id: selectedPatientId,
 		                    },
-		                    system_prompts: {
-		                        surveyor: (surveyorSystemPrompt || '').trim(),
-		                        patient: (patientSystemPrompt || '').trim(),
-		                    },
-		                    analysis_agent: {
-		                        attributes: (analysisAttributeItems || [])
-		                            .map((x) => (typeof x === 'string' ? x.trim() : ''))
-		                            .filter((x) => x.length > 0),
-		                    },
 		                    saved_at: new Date().toISOString()
 		                });
 		                saveConfig(cfg);
-		                setSavedAt(cfg.saved_at);
-		                setSaveFlash(true);
-		                setTimeout(() => setSaveFlash(false), 1000);
+
+		                const body = {
+		                    surveyor_system_prompt: (surveyorSystemPrompt || '').trim(),
+		                    patient_system_prompt: (patientSystemPrompt || '').trim(),
+		                    analysis_attributes: (analysisAttributeItems || []).map((x) => (typeof x === 'string' ? x.trim() : '')).filter((x) => x.length > 0),
+		                };
+
+		                Promise.all([
+		                    authedFetch('/api/settings', {
+		                        method: 'PUT',
+		                        headers: { 'Content-Type': 'application/json' },
+		                        body: JSON.stringify(body)
+		                    }).catch(() => null),
+		                    (activePane === 'surveyors' && surveyorPersonaDetail && surveyorPersonaDetail.is_default === false)
+		                        ? authedFetch(`/api/personas/${selectedSurveyorId}`, {
+		                            method: 'PUT',
+		                            headers: { 'Content-Type': 'application/json' },
+		                            body: JSON.stringify({
+		                                attributes: (surveyorAttributeItems || []).map((x) => (typeof x === 'string' ? x.trim() : '')).filter((x) => x.length > 0),
+		                                question_bank_items: (surveyorQuestionItems || []).map((q) => (q && typeof q.text === 'string' ? q.text.trim() : '')).filter((t) => t.length > 0),
+		                            })
+		                        }).catch(() => null)
+		                        : Promise.resolve(null),
+		                    (activePane === 'patients' && patientPersonaDetail && patientPersonaDetail.is_default === false)
+		                        ? authedFetch(`/api/personas/${selectedPatientId}`, {
+		                            method: 'PUT',
+		                            headers: { 'Content-Type': 'application/json' },
+		                            body: JSON.stringify({
+		                                attributes: (patientAttributeItems || []).map((x) => (typeof x === 'string' ? x.trim() : '')).filter((x) => x.length > 0),
+		                                question_bank_items: [],
+		                            })
+		                        }).catch(() => null)
+		                        : Promise.resolve(null),
+		                ]).then(() => {
+		                    setSavedAt(cfg.saved_at);
+		                    setSaveFlash(true);
+		                    setTimeout(() => setSaveFlash(false), 1000);
+		                });
+		            };
+
+		            const createPersona = async (kind, cloneFromId) => {
+		                const base = (kind === 'surveyor') ? 'New surveyor persona name' : 'New patient persona name';
+		                const suggested = cloneFromId
+		                    ? `Copy of ${(kind === 'surveyor' ? surveyorPersonaDetail?.name : patientPersonaDetail?.name) || 'Persona'}`
+		                    : '';
+		                const name = window.prompt(base, suggested) || '';
+		                if (!name.trim()) return null;
+		                const res = await authedFetch('/api/personas', {
+		                    method: 'POST',
+		                    headers: { 'Content-Type': 'application/json' },
+		                    body: JSON.stringify({
+		                        kind,
+		                        name: name.trim(),
+		                        clone_from_persona_id: cloneFromId || undefined,
+		                    })
+		                });
+		                if (!res.ok) return null;
+		                const data = await res.json();
+		                await refreshPersonas();
+		                return data?.id || null;
+		            };
+
+		            const deletePersona = async (personaId) => {
+		                if (!personaId) return false;
+		                const ok = window.confirm('Delete this persona? This cannot be undone.');
+		                if (!ok) return false;
+		                const res = await authedFetch(`/api/personas/${personaId}`, { method: 'DELETE' });
+		                if (!res.ok) return false;
+		                await refreshPersonas();
+		                return true;
 		            };
 
             const TabNav = () => {
@@ -186,7 +300,7 @@ You will also be given persona-specific attributes.`;
 	                        <div>
 	                            <h2 className="text-xl font-bold text-slate-800">Configuration</h2>
 	                            <p className="text-slate-600 mt-1 text-sm">
-	                                Use this panel to edit persona-specific settings in this browser. Persona selection for runs is done in the AI-to-AI / Human-to-AI panels.
+	                                Use this panel to edit shared app settings and personas. Persona selection for runs is done in the AI-to-AI / Human-to-AI panels.
 	                            </p>
 	                        </div>
 	                    </div>
@@ -220,7 +334,7 @@ You will also be given persona-specific attributes.`;
 	                            <div className="grid grid-cols-2 gap-6 items-end">
 	                                <div>
 		                                <label className="block text-sm font-semibold text-slate-700 mb-2">Review surveyor persona</label>
-	                                    <div className="flex">
+	                                    <div className="flex items-center gap-2 flex-wrap">
 		                                    <select
 		                                        className="w-full md:w-1/4 border border-slate-300 rounded-lg px-3 py-2 text-sm bg-white"
 		                                        value={selectedSurveyorId}
@@ -230,6 +344,41 @@ You will also be given persona-specific attributes.`;
 			                                            <option key={p.id} value={p.id}>{p.name}</option>
 			                                        ))}
 		                                    </select>
+		                                    <button
+		                                        type="button"
+		                                        onClick={async () => {
+		                                            const id = await createPersona('surveyor', null);
+		                                            if (id) setSelectedSurveyorId(id);
+		                                        }}
+		                                        className="bg-slate-100 hover:bg-slate-200 text-slate-800 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-slate-300"
+		                                    >
+		                                        + New
+		                                    </button>
+		                                    <button
+		                                        type="button"
+		                                        onClick={async () => {
+		                                            const id = await createPersona('surveyor', selectedSurveyorId);
+		                                            if (id) setSelectedSurveyorId(id);
+		                                        }}
+		                                        className="bg-slate-100 hover:bg-slate-200 text-slate-800 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-slate-300"
+		                                    >
+		                                        Duplicate
+		                                    </button>
+		                                    <button
+		                                        type="button"
+		                                        disabled={!(surveyorPersonaDetail && surveyorPersonaDetail.is_default === false)}
+		                                        onClick={async () => {
+		                                            const ok = await deletePersona(selectedSurveyorId);
+		                                            if (ok) {
+		                                                const data = await refreshPersonas();
+		                                                const fallback = (data?.surveyors && data.surveyors[0] && data.surveyors[0].id) ? data.surveyors[0].id : 'friendly_researcher_001';
+		                                                setSelectedSurveyorId(fallback);
+		                                            }
+		                                        }}
+		                                        className="bg-white hover:bg-red-50 text-red-700 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-red-200 disabled:opacity-50 disabled:hover:bg-white"
+		                                    >
+		                                        Delete
+		                                    </button>
 	                                    </div>
 	                                </div>
 	                                <div />
@@ -237,7 +386,9 @@ You will also be given persona-specific attributes.`;
 
 	                            <div className="grid grid-cols-2 gap-6">
 	                                <div>
-	                                    <label className="block text-sm font-semibold text-slate-700 mb-2">Attributes (read-only)</label>
+	                                    <label className="block text-sm font-semibold text-slate-700 mb-2">
+	                                        Attributes {surveyorPersonaDetail?.is_default === false ? '' : '(read-only)'}
+	                                    </label>
 	                                    <div className="space-y-2">
 	                                        {(surveyorAttributeItems || []).length === 0 ? (
 	                                            <div className="text-sm text-slate-500">No attributes.</div>
@@ -246,18 +397,41 @@ You will also be given persona-specific attributes.`;
 	                                                <div key={idx} className="flex items-start gap-2">
 	                                                    <div className="mt-2 text-xs font-mono text-slate-500 w-10 shrink-0">{String(idx + 1).padStart(2, '0')}</div>
 	                                                    <input
-	                                                        className="flex-1 border border-slate-300 rounded-lg px-3 py-2 text-sm bg-slate-50 text-slate-600"
+	                                                        className={`flex-1 border border-slate-300 rounded-lg px-3 py-2 text-sm ${surveyorPersonaDetail?.is_default === false ? 'bg-white' : 'bg-slate-50 text-slate-600'}`}
 	                                                        value={attr || ''}
-	                                                        disabled
+	                                                        onChange={(e) => updateSurveyorAttribute(idx, e.target.value)}
+	                                                        disabled={!(surveyorPersonaDetail?.is_default === false)}
+	                                                        placeholder="Type an attribute..."
 	                                                    />
+	                                                    {surveyorPersonaDetail?.is_default === false && (
+	                                                        <button
+	                                                            type="button"
+	                                                            onClick={() => removeSurveyorAttribute(idx)}
+	                                                            className="text-slate-600 hover:text-red-600 px-2 py-2 text-sm"
+	                                                            title="Remove attribute"
+	                                                        >
+	                                                            ✕
+	                                                        </button>
+	                                                    )}
 	                                                </div>
 	                                            ))
 	                                        )}
+	                                        {surveyorPersonaDetail?.is_default === false && (
+	                                            <button
+	                                                type="button"
+	                                                onClick={addSurveyorAttribute}
+	                                                className="bg-slate-100 hover:bg-slate-200 text-slate-800 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-slate-300"
+	                                            >
+	                                                + Add attribute
+	                                            </button>
+	                                        )}
 	                                    </div>
 	                                </div>
 
 	                                <div>
-	                                    <label className="block text-sm font-semibold text-slate-700 mb-2">Question bank (read-only)</label>
+	                                    <label className="block text-sm font-semibold text-slate-700 mb-2">
+	                                        Question bank {surveyorPersonaDetail?.is_default === false ? '' : '(read-only)'}
+	                                    </label>
 	                                    <div className="space-y-2">
 	                                        {(surveyorQuestionItems || []).length === 0 ? (
 	                                            <div className="text-sm text-slate-500">No questions.</div>
@@ -266,13 +440,34 @@ You will also be given persona-specific attributes.`;
 	                                                <div key={q.id} className="flex items-start gap-2">
 	                                                    <div className="mt-2 text-xs font-mono text-slate-500 w-10 shrink-0">{q.id}</div>
 	                                                    <input
-	                                                        className="flex-1 border border-slate-300 rounded-lg px-3 py-2 text-sm bg-slate-50 text-slate-600"
+	                                                        className={`flex-1 border border-slate-300 rounded-lg px-3 py-2 text-sm ${surveyorPersonaDetail?.is_default === false ? 'bg-white' : 'bg-slate-50 text-slate-600'}`}
 	                                                        value={q.text || ''}
-	                                                        disabled
+	                                                        onChange={(e) => updateSurveyorQuestionText(q.id, e.target.value)}
+	                                                        disabled={!(surveyorPersonaDetail?.is_default === false)}
+	                                                        placeholder="Type a question..."
 	                                                    />
+	                                                    {surveyorPersonaDetail?.is_default === false && (
+	                                                        <button
+	                                                            type="button"
+	                                                            onClick={() => removeSurveyorQuestion(q.id)}
+	                                                            className="text-slate-600 hover:text-red-600 px-2 py-2 text-sm"
+	                                                            title="Remove question"
+	                                                        >
+	                                                            ✕
+	                                                        </button>
+	                                                    )}
 	                                                </div>
 	                                            ))
 	                                        )}
+	                                        {surveyorPersonaDetail?.is_default === false && (
+	                                            <button
+	                                                type="button"
+	                                                onClick={addSurveyorQuestion}
+	                                                className="bg-slate-100 hover:bg-slate-200 text-slate-800 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-slate-300"
+	                                            >
+	                                                + Add question
+	                                            </button>
+	                                        )}
 	                                    </div>
 	                                </div>
 	                            </div>
@@ -304,7 +499,7 @@ You will also be given persona-specific attributes.`;
                             <div className="grid grid-cols-2 gap-6 items-end">
                                 <div>
                                     <label className="block text-sm font-semibold text-slate-700 mb-2">Review patient persona</label>
-                                    <div className="flex">
+                                    <div className="flex items-center gap-2 flex-wrap">
                                         <select
                                             className="w-full md:w-1/4 border border-slate-300 rounded-lg px-3 py-2 text-sm bg-white"
                                             value={selectedPatientId}
@@ -314,6 +509,41 @@ You will also be given persona-specific attributes.`;
 	                                            <option key={p.id} value={p.id}>{p.name}</option>
 	                                        ))}
                                         </select>
+		                                <button
+		                                    type="button"
+		                                    onClick={async () => {
+		                                        const id = await createPersona('patient', null);
+		                                        if (id) setSelectedPatientId(id);
+		                                    }}
+		                                    className="bg-slate-100 hover:bg-slate-200 text-slate-800 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-slate-300"
+		                                >
+		                                    + New
+		                                </button>
+		                                <button
+		                                    type="button"
+		                                    onClick={async () => {
+		                                        const id = await createPersona('patient', selectedPatientId);
+		                                        if (id) setSelectedPatientId(id);
+		                                    }}
+		                                    className="bg-slate-100 hover:bg-slate-200 text-slate-800 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-slate-300"
+		                                >
+		                                    Duplicate
+		                                </button>
+		                                <button
+		                                    type="button"
+		                                    disabled={!(patientPersonaDetail && patientPersonaDetail.is_default === false)}
+		                                    onClick={async () => {
+		                                        const ok = await deletePersona(selectedPatientId);
+		                                        if (ok) {
+		                                            const data = await refreshPersonas();
+		                                            const fallback = (data?.patients && data.patients[0] && data.patients[0].id) ? data.patients[0].id : 'cooperative_senior_001';
+		                                            setSelectedPatientId(fallback);
+		                                        }
+		                                    }}
+		                                    className="bg-white hover:bg-red-50 text-red-700 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-red-200 disabled:opacity-50 disabled:hover:bg-white"
+		                                >
+		                                    Delete
+		                                </button>
                                     </div>
                                 </div>
                                 <div />
@@ -321,7 +551,9 @@ You will also be given persona-specific attributes.`;
 
                             <div className="grid grid-cols-2 gap-6">
                                 <div>
-                                    <label className="block text-sm font-semibold text-slate-700 mb-2">Attributes (read-only)</label>
+                                    <label className="block text-sm font-semibold text-slate-700 mb-2">
+                                        Attributes {patientPersonaDetail?.is_default === false ? '' : '(read-only)'}
+                                    </label>
                                     <div className="space-y-2">
                                         {(patientAttributeItems || []).length === 0 ? (
                                             <div className="text-sm text-slate-500">No attributes.</div>
@@ -330,13 +562,34 @@ You will also be given persona-specific attributes.`;
                                                 <div key={idx} className="flex items-start gap-2">
                                                     <div className="mt-2 text-xs font-mono text-slate-500 w-10 shrink-0">{String(idx + 1).padStart(2, '0')}</div>
                                                     <input
-                                                        className="flex-1 border border-slate-300 rounded-lg px-3 py-2 text-sm bg-slate-50 text-slate-600"
+                                                        className={`flex-1 border border-slate-300 rounded-lg px-3 py-2 text-sm ${patientPersonaDetail?.is_default === false ? 'bg-white' : 'bg-slate-50 text-slate-600'}`}
                                                         value={attr || ''}
-                                                        disabled
+                                                        onChange={(e) => updatePatientAttribute(idx, e.target.value)}
+                                                        disabled={!(patientPersonaDetail?.is_default === false)}
+                                                        placeholder="Type an attribute..."
                                                     />
+                                                    {patientPersonaDetail?.is_default === false && (
+                                                        <button
+                                                            type="button"
+                                                            onClick={() => removePatientAttribute(idx)}
+                                                            className="text-slate-600 hover:text-red-600 px-2 py-2 text-sm"
+                                                            title="Remove attribute"
+                                                        >
+                                                            ✕
+                                                        </button>
+                                                    )}
                                                 </div>
                                             ))
                                         )}
+                                        {patientPersonaDetail?.is_default === false && (
+                                            <button
+                                                type="button"
+                                                onClick={addPatientAttribute}
+                                                className="bg-slate-100 hover:bg-slate-200 text-slate-800 px-3 py-2 rounded-lg text-sm font-semibold transition-all border border-slate-300"
+                                            >
+                                                + Add attribute
+                                            </button>
+                                        )}
                                     </div>
                                 </div>
                                 <div />

frontend/pages/main_page.py

@@ -57,10 +57,6 @@ def get_main_page_html(auth_enabled: bool = False) -> str:
 	            return (cfg && cfg.analysis_agent && typeof cfg.analysis_agent === 'object') ? cfg.analysis_agent : {};
 	        }
 
-	        function getSystemPromptsStore(cfg) {
-	            return (cfg && cfg.system_prompts && typeof cfg.system_prompts === 'object') ? cfg.system_prompts : {};
-	        }
-
 	        function getSurveyorPersonaData(cfg, surveyorId) {
 	            if (!surveyorId) return null;
 	            const store = getSurveyorPersonaStore(cfg);
@@ -687,11 +683,6 @@ def get_main_page_html(auth_enabled: bool = False) -> str:
 	                connectWebSocket('main');
 	                const surveyorId = mainSurveyorId || 'friendly_researcher_001';
 	                const patientId = mainPatientId || 'cooperative_senior_001';
-	                const cfg = loadConfig() || {};
-	                const systemPrompts = getSystemPromptsStore(cfg);
-	                const surveyorSystemPrompt = (typeof systemPrompts.surveyor === 'string') ? systemPrompts.surveyor : '';
-	                const patientSystemPrompt = (typeof systemPrompts.patient === 'string') ? systemPrompts.patient : '';
-	                const analysisAttributes = getAnalysisAttributesFor(cfg);
 
                 setTimeout(() => {
                     if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
@@ -699,9 +690,6 @@ def get_main_page_html(auth_enabled: bool = False) -> str:
 	                            type: 'start_conversation',
 	                            surveyor_persona_id: surveyorId,
 	                            patient_persona_id: patientId,
-	                            surveyor_system_prompt: surveyorSystemPrompt || undefined,
-	                            patient_system_prompt: patientSystemPrompt || undefined,
-	                            analysis_attributes: analysisAttributes.length ? analysisAttributes : undefined,
 	                        }));
 	                    }
 	                }, 500);
@@ -720,11 +708,6 @@ def get_main_page_html(auth_enabled: bool = False) -> str:
 	                connectWebSocket('human');
 	                const surveyorId = humanSurveyorId || 'friendly_researcher_001';
 	                const patientId = humanPatientId || 'cooperative_senior_001';
-	                const cfg = loadConfig() || {};
-	                const systemPrompts = getSystemPromptsStore(cfg);
-	                const surveyorSystemPrompt = (typeof systemPrompts.surveyor === 'string') ? systemPrompts.surveyor : '';
-	                const patientSystemPrompt = (typeof systemPrompts.patient === 'string') ? systemPrompts.patient : '';
-	                const analysisAttributes = getAnalysisAttributesFor(cfg);
 
                 setTimeout(() => {
                     if (wsRef.current && wsRef.current.readyState === WebSocket.OPEN) {
@@ -733,9 +716,6 @@ def get_main_page_html(auth_enabled: bool = False) -> str:
 	                            ai_role: humanAiRole || 'surveyor',
 	                            surveyor_persona_id: surveyorId,
 	                            patient_persona_id: patientId,
-	                            surveyor_system_prompt: surveyorSystemPrompt || undefined,
-	                            patient_system_prompt: patientSystemPrompt || undefined,
-	                            analysis_attributes: analysisAttributes.length ? analysisAttributes : undefined,
 	                        }));
 	                    }
 	                }, 500);
@@ -795,11 +775,6 @@ def get_main_page_html(auth_enabled: bool = False) -> str:
                     fd.append('file', file);
                     fd.append('conversation_id', conversationId);
                     if (file.name) fd.append('source_name', file.name);
-                    {
-                        const cfg = loadConfig() || {};
-                        const analysisAttributes = getAnalysisAttributesFor(cfg);
-                        if (analysisAttributes.length) fd.append('analysis_attributes_json', JSON.stringify(analysisAttributes));
-                    }
 
                     const res = await authedFetchForm('/api/analyze/file', fd);
                     if (!res.ok) {
@@ -844,16 +819,13 @@ def get_main_page_html(auth_enabled: bool = False) -> str:
                 analysisConversationIdRef.current = conversationId;
 
                 try {
-                    const cfg = loadConfig() || {};
-                    const analysisAttributes = getAnalysisAttributesFor(cfg);
                     const res = await authedFetch('/api/analyze/text', {
                         method: 'POST',
                         headers: { 'Content-Type': 'application/json' },
                         body: JSON.stringify({
                             conversation_id: conversationId,
                             source_name: analysisSourceName || undefined,
-                            text,
-                            analysis_attributes: analysisAttributes.length ? analysisAttributes : undefined,
+                            text
                         })
                     });
                     if (!res.ok) {

frontend/react_gradio_hybrid.py

@@ -21,7 +21,7 @@ from websocket_manager import WebSocketManager
 from backend.api.main import app as backend_app
 from backend.api.conversation_ws import manager as backend_ws_manager
 from backend.api.conversation_service import initialize_conversation_service
-from backend.api.storage_service import initialize_run_store
+from backend.api.storage_service import initialize_run_store, seed_personas_and_settings
 from backend.core.auth import (
     COOKIE_NAME,
     INTERNAL_HEADER,
@@ -50,6 +50,7 @@ app.mount("/api", backend_app)
 async def initialize_backend_services():
     initialize_conversation_service(backend_ws_manager, settings)
     await initialize_run_store(settings)
+    await seed_personas_and_settings(overwrite_defaults=True)
 
 
 # Enable CORS for local development
@@ -164,9 +165,6 @@ async def frontend_websocket(websocket: WebSocket, conversation_id: str):
                         "content": "start",
                         "surveyor_persona_id": data.get("surveyor_persona_id", "friendly_researcher_001"),
                         "patient_persona_id": data.get("patient_persona_id", "cooperative_senior_001"),
-                        "surveyor_system_prompt": data.get("surveyor_system_prompt"),
-                        "patient_system_prompt": data.get("patient_system_prompt"),
-                        "analysis_attributes": data.get("analysis_attributes"),
                         "host": settings.llm.host,
                         "model": settings.llm.model,
                     })
@@ -188,9 +186,6 @@ async def frontend_websocket(websocket: WebSocket, conversation_id: str):
                         "ai_role": data.get("ai_role"),
                         "surveyor_persona_id": data.get("surveyor_persona_id", "friendly_researcher_001"),
                         "patient_persona_id": data.get("patient_persona_id", "cooperative_senior_001"),
-                        "surveyor_system_prompt": data.get("surveyor_system_prompt"),
-                        "patient_system_prompt": data.get("patient_system_prompt"),
-                        "analysis_attributes": data.get("analysis_attributes"),
                         "host": settings.llm.host,
                         "model": settings.llm.model,
                     })