Add all folders and files

Co-authored-by: Codex <noreply@openai.com>

.dockerignore

@@ -0,0 +1,19 @@
+.git
+.gitignore
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.venv/
+venv/
+env/
+artifacts/
+logs/
+models/*
+!models/all-MiniLM-L6-v2
+!models/NVIDIA-Nemotron-Parse-v1.1
+!models/cohere-transcribe-03-2026
+*.sqlite3
+*.db
+*.log

.gitignore

@@ -0,0 +1,18 @@
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+
+# Local artifacts / caches
+models/
+data/artifacts/
+artifacts/
+*.sqlite3
+*.db
+
+# OS/editor
+.DS_Store
+.vscode/
+.idea/

CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## Unreleased
+
+### Added
+- Added `scripts/share_traces_to_hf_dataset.py`, canonical trace payload fields (`timestamp`, `inputs`, `parsed_outputs`, `model_name`), and offline JSONL/metadata materialization for sharing trace artifacts.
+- Added a P1 standalone-repo cleanup pass to remove cross-project sqlite leftovers and cross-project landing-page references.
+- Added a repo data inventory and README attribution links.
+
+### Changed
+- Updated trace artifact generation to expose share-friendly schema fields for dataset export and verification.
+- Lazy-imported Gradio from the P1 app entrypoint so test and eval imports do not require the UI dependency.

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim AS llama-builder
+ENV DEBIAN_FRONTEND=noninteractive
+WORKDIR /opt/llama.cpp
+RUN apt-get update     && apt-get install -y --no-install-recommends build-essential cmake git pkg-config libcurl4-openssl-dev     && rm -rf /var/lib/apt/lists/*
+RUN git clone --depth 1 https://github.com/ggml-org/llama.cpp.git .
+RUN cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DGGML_NATIVE=OFF -DLLAMA_BUILD_TESTS=OFF     && cmake --build build -j$(nproc)
+
+FROM python:3.11-slim AS runtime
+ENV DEBIAN_FRONTEND=noninteractive     PYTHONDONTWRITEBYTECODE=1     PYTHONUNBUFFERED=1     PORT=7860     GRADIO_SERVER_NAME=0.0.0.0
+WORKDIR /app
+RUN apt-get update     && apt-get install -y --no-install-recommends ca-certificates libcurl4 libgomp1 libstdc++6     && rm -rf /var/lib/apt/lists/*
+COPY requirements.txt ./requirements.txt
+RUN python -m pip install --no-cache-dir --upgrade pip setuptools wheel     && python -m pip install --no-cache-dir -r requirements.txt
+COPY . .
+COPY --from=llama-builder /opt/llama.cpp/build/bin/llama-server /usr/local/bin/llama-server
+COPY --from=llama-builder /opt/llama.cpp/build/bin/llama-cli /usr/local/bin/llama-cli
+
+ARG HF_TOKEN
+ENV HF_TOKEN=${HF_TOKEN}
+RUN pip install huggingface_hub hf_transfer
+RUN python scripts/download_gguf.py openbmb/MiniCPM5-1B-GGUF MiniCPM5-1B-Q4_K_M.gguf models/MiniCPM5-1B-Q4_K_M.gguf
+EXPOSE 7860 8080
+CMD ["python", "app.py"]

FIELD_NOTES.md

@@ -0,0 +1,8 @@
+ Elder Paperwork Co-Pilot demonstrates a well-structured offline-first AI assistant for medical paperwork summarization. 
+ Key observations:
+- Clean separation of concerns with dedicated directories for apps, models, data, configs, and scripts
+- Comprehensive documentation including README, FIELD_NOTES.md, and verification reports
+- Thoughtful attention to offline operation and data privacy (no PII/PHI in demo packs)
+- Clear pathways for local execution via Python, virtualenv, or Docker
+- Strong emphasis on reproducible verification through structured test suites and eval runners
+The project successfully implements its goal of providing an offline AI assistant for eldercare paperwork, with room for future enhancement through live model integration and performance benchmarking.

README.md

@@ -1,14 +1,161 @@
----
-title: Elder Care Copilot
-emoji: 🏃
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
-short_description: AI assistant that securely summarizes complex medical docs
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# P1 Elder Paperwork Co-Pilot
+
+> An offline AI assistant that securely summarizes complex medical paperwork.
+
+Standalone Hugging Face Space repo for the P1 elder-paperwork demo.
+
+What this repo contains:
+- the split app entrypoint for this repo only
+- the shared helper modules needed by the app and its eval runner
+- only the demo packs that belong to this split repo
+
+## Local run
+
+From the repo root:
+
+```bash
+python app.py
+```
+
+If you prefer an isolated environment:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+python app.py
+```
+
+The app listens on PORT when set; otherwise `app.py` picks an available local port for local runs.
+
+Trace artifacts are written on every demo-pack load or eval run. Use the Load sample data button in the UI or the eval runner JSON `trace_path` field to find the file under `data/artifacts/<project>/traces/`.
+
+## Off-brand UI
+
+Custom styling lives in `assets/theme.css`.
+Edit that file to tune the accessible high-contrast palette, spacing, and typography.
+The app loads it at launch via Gradio `css_paths`.
+
+## Llama Champion smoke
+
+The main app stays on its normal offline-first path; the badge is satisfied by a dedicated local GGUF smoke that exercises `llama-cpp-python` end-to-end and writes a small verification artifact.
+
+P1 uses `openbmb/MiniCPM5-1B-GGUF` (`MiniCPM5-1B-Q4_K_M.gguf`) as the preferred local GGUF because it matches the registry's MiniCPM-5-1B family.
+
+Install dependencies with your normal venv flow; `requirements.txt` already points pip at the CPU wheel index for `llama-cpp-python==0.3.28`.
+
+Download the model into `models/`:
+
+```bash
+mkdir -p models
+huggingface-cli download openbmb/MiniCPM5-1B-GGUF MiniCPM5-1B-Q4_K_M.gguf --local-dir models
+```
+
+Direct smoke from the repo root:
+
+```bash
+LLAMA_CHAMPION_MODEL=models/MiniCPM5-1B-Q4_K_M.gguf python scripts/llama_champion_smoke.py --artifact-path artifacts/verification/$(date +%F)/llama_champion_smoke.json
+```
+
+The script writes `artifacts/verification/<YYYY-MM-DD>/llama_champion_smoke.json` by default if you omit `--artifact-path`.
+
+Pytest wrapper:
+
+```bash
+LLAMA_CHAMPION_MODEL=models/MiniCPM5-1B-Q4_K_M.gguf .venv/bin/python -m pytest -q tests/test_llama_champion_smoke.py
+```
+
+If the pytest env does not already have `llama_cpp`, set `LLAMA_CHAMPION_PYTHON` to the interpreter that does.
+
+## Docker
+
+Build the image:
+
+```bash
+docker build -t all4-p1 .
+```
+
+Run the app container:
+
+```bash
+docker run --rm -p 7860:7860 all4-p1
+```
+
+Optional: run the bundled llama.cpp server from the same image with the same GGUF used above:
+
+```bash
+docker run --rm -p 8080:8080 -v "$PWD/models:/models" --entrypoint llama-server all4-p1   --model /models/MiniCPM5-1B-Q4_K_M.gguf --host 0.0.0.0 --port 8080
+```
+
+Notes:
+- The image is CPU-only and multi-stage; it builds llama.cpp in a builder stage and keeps the runtime stage lean.
+- `.venv/` is ignored by the Docker build context, so local virtualenvs do not get baked into the image.
+- The app and llama-server share the same image but are launched separately.
+
+## Offline verification
+
+Run the bundled offline smoke check from the repo root:
+
+```bash
+bash scripts/offline_smoke.sh
+```
+
+CI-friendly pytest wrapper:
+
+```bash
+python -m pytest -q tests/test_offline_smoke.py
+```
+
+Docker variant with outbound networking disabled:
+
+```bash
+docker run --rm --network none -v "$PWD:/repo" -w /repo all4-p1 bash scripts/offline_smoke.sh
+```
+
+The smoke check loads a bundled demo pack, blocks socket/HTTP client creation, and fails if any runtime code tries to reach the network.
+
+
+## Sponsor model policy gate
+
+Run the repo-local sponsor gate without Docker:
+
+```bash
+python scripts/check_sponsor_model_policy.py
+pytest -q tests/test_sponsor_model_policy.py
+```
+
+The gate checks that the registry matches the four planned P1 sponsor components before any packaging or Docker verification step.
+
+## Field notes
+
+See [FIELD_NOTES.md](FIELD_NOTES.md) for the badge artifact, evidence notes, and next steps.
+
+## Sharing traces
+
+Use `python scripts/share_traces_to_hf_dataset.py <traces-dir>` to materialize a deterministic JSONL + metadata bundle under `artifacts/verification/<YYYY-MM-DD>/sharing_is_caring/all4-p1-elder-paperwork/`.
+
+- The default mode is local-only; pass `--push` plus `--repo-id` and `HF_TOKEN` to publish a Hugging Face Dataset bundle.
+- `--dry-run` forces offline materialization even when `--push` is present.
+- See `CHANGELOG.md` for the latest trace-sharing notes.
+## Submission assets
+
+Fill these TODO fields before final submission; they are placeholders only and do not imply the assets already exist.
+
+- [ ] TODO Hugging Face Space URL (build-small org): `<SPACE_URL>`
+- [ ] TODO Public GitHub repo URL: `<REPO_URL>`
+- [ ] TODO Demo video URL: `<VIDEO_URL>`
+- [ ] TODO Social post URL: `<SOCIAL_POST_URL>`
+- [ ] TODO Concise disclaimer: synthetic/repo-authored demo packs only; no PII/PHI.
+- [ ] TODO Sponsor model attribution list:
+  - OpenBMB MiniCPM-V 4.6: `openbmb/MiniCPM-V-4_6` for `ocr_vlm`
+  - OpenBMB MiniCPM-5 1B: `openbmb/MiniCPM-5-1B` for `triage_llm`
+  - NVIDIA NeMoTRON-PARS: `nvidia/NeMoTRON-PARS` for `table_parser`
+  - CoExpression Labs Co-Transcribe 2B: `CoExpressionLabs/co-transcribe-2b` for `asr`
+
+## Models and data attributions
+
+- The bundled demo packs are synthetic or repo-authored and are licensed CC0-1.0 unless a subfolder README says otherwise.
+- The sponsor-required P1 registry entries are the four models listed above; keep `configs/model_registry.yaml` and `configs/sponsor_model_policy.yaml` aligned if you change them.
+- The shared `summary_llm` helper also uses `openbmb/MiniCPM-5-1B`, but it is not part of the sponsor gate.
+- The sample GGUF above is only an example; use a model whose license and size are suitable for your deployment.
+- No PII/PHI is included in the shipped demo packs.

app.py

@@ -1,7 +1,45 @@
-import gradio as gr
+from __future__ import annotations
 
-def greet(name):
-    return "Hello " + name + "!!"
+import os
+import socket
+import sys
+from pathlib import Path
 
-demo = gr.Interface(fn=greet, inputs="text", outputs="text")
-demo.launch()
+ROOT_DIR = Path(__file__).resolve().parent
+SRC_DIR = ROOT_DIR / "src"
+
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+os.environ.setdefault("APP_ROOT_DIR", str(ROOT_DIR))
+os.environ.setdefault("DATA_DIR", str(ROOT_DIR / "data"))
+os.environ.setdefault("MODEL_REGISTRY_PATH", str(ROOT_DIR / "configs" / "model_registry.yaml"))
+os.environ.setdefault("MODEL_CACHE_DIR", str(ROOT_DIR / "models"))
+os.environ.setdefault("ARTIFACT_DIR", str(ROOT_DIR / "data" / "artifacts"))
+
+import shutil
+sqlite_src = ROOT_DIR / "data" / "sqlite" / "p1.sqlite3"
+sqlite_tmp = Path("/tmp/p1.sqlite3")
+if sqlite_src.exists() and not sqlite_tmp.exists():
+    shutil.copy2(sqlite_src, sqlite_tmp)
+os.environ.setdefault("SQLITE_PATH", str(sqlite_tmp))
+
+from apps.p1_elder_paperwork.app import main as p1_main  # noqa: E402
+
+
+def _pick_port() -> int:
+    port_env = os.environ.get("PORT")
+    if port_env:
+        return int(port_env)
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+def main() -> int:
+    os.environ.setdefault("PORT", str(_pick_port()))
+    return p1_main()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

app_kit/__init__.py

@@ -0,0 +1,23 @@
+from .config import AppConfig, load_app_config
+from .demo_packs import DemoPack, load_demo_pack, list_demo_packs
+from .model_registry import load_model_registry
+from .storage import SQLiteStore
+
+__all__ = [
+    'AppConfig',
+    'DemoPack',
+    'SQLiteStore',
+    'list_demo_packs',
+    'load_app_config',
+    'load_demo_pack',
+    'load_model_registry',
+    'run_eval_for_project',
+]
+
+
+def __getattr__(name: str):
+    if name == 'run_eval_for_project':
+        from .eval_runner import run_eval_for_project
+
+        return run_eval_for_project
+    raise AttributeError(f'module {__name__!r} has no attribute {name!r}')

app_kit/__main__.py

@@ -0,0 +1,3 @@
+from .server import main
+
+raise SystemExit(main())

app_kit/care_circle.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import re
+import shutil
+from typing import Iterable
+
+TOKEN_RE = re.compile(r"[A-Za-zÀ-ÿ0-9']+")
+SENTENCE_RE = re.compile(r'(?<=[.!?])\s+')
+
+MOOD_TERMS = {
+    'tired': 'mood:tired',
+    'sad': 'mood:sad',
+    'anxious': 'mood:anxious',
+    'worried': 'mood:worried',
+    'calm': 'mood:calm',
+    'better': 'mood:improving',
+}
+SYMPTOM_TERMS = {
+    'pain': 'symptoms:pain',
+    'dizzy': 'symptoms:dizziness',
+    'dizziness': 'symptoms:dizziness',
+    'cough': 'symptoms:cough',
+    'fever': 'symptoms:fever',
+    'nausea': 'symptoms:nausea',
+    'appetite': 'symptoms:low_appetite',
+    'breath': 'symptoms:shortness_of_breath',
+}
+ACTIVITY_TERMS = {
+    'walk': 'activity:walking',
+    'walking': 'activity:walking',
+    'rest': 'activity:resting',
+    'sleep': 'activity:sleep',
+    'slept': 'activity:sleep',
+    'visit': 'activity:visit',
+    'appointment': 'activity:appointment',
+}
+MEDICATION_TERMS = {
+    'medication': 'meds:medication',
+    'meds': 'meds:medication',
+    'dose': 'meds:dose_change',
+    'pill': 'meds:pill',
+    'refill': 'meds:refill',
+}
+RISK_TERMS = {
+    'hurt',
+    'harm',
+    'abuse',
+    'suicide',
+    'kill',
+    'overdose',
+    'emergency',
+}
+
+
+@dataclass(frozen=True)
+class JournalSummary:
+    transcript: str
+    family_view: str
+    clinician_view: str
+    tags: list[str]
+    segment_confidences: list[dict[str, object]]
+    safety_tag: str
+    questions_for_doctor: list[str]
+
+
+def tokenize(text: str) -> list[str]:
+    return [token.lower() for token in TOKEN_RE.findall(text or '')]
+
+
+def extract_tags(text: str) -> list[str]:
+    tokens = tokenize(text)
+    tags: list[str] = []
+    for token in tokens:
+        for mapping in (MOOD_TERMS, SYMPTOM_TERMS, ACTIVITY_TERMS, MEDICATION_TERMS):
+            if token in mapping and mapping[token] not in tags:
+                tags.append(mapping[token])
+    if not tags:
+        tags.append('care:general')
+    return tags
+
+
+def safety_label(text: str) -> str:
+    lowered = (text or '').lower()
+    return 'needs review' if any(term in lowered for term in RISK_TERMS) else 'ok'
+
+
+def _shorten(text: str, limit: int = 160) -> str:
+    text = ' '.join((text or '').split())
+    return text if len(text) <= limit else text[: limit - 1].rstrip() + '…'
+
+
+def family_summary(text: str) -> str:
+    sentences = [sentence.strip() for sentence in SENTENCE_RE.split((text or '').strip()) if sentence.strip()]
+    if not sentences:
+        return 'No transcript provided.'
+    first = _shorten(sentences[0], 170)
+    tags = extract_tags(text)
+    return f'Family update: {first}. Tags: {", ".join(tags[:4])}.'
+
+
+def clinician_summary(text: str) -> str:
+    tags = extract_tags(text)
+    first = _shorten((text or '').split('\n', 1)[0], 140)
+    return f'Clinician note: {first}. Relevant tags: {", ".join(tags[:4])}.'
+
+
+def segment_confidences(text: str) -> list[dict[str, object]]:
+    sentences = [sentence.strip() for sentence in SENTENCE_RE.split((text or '').strip()) if sentence.strip()]
+    if not sentences:
+        sentences = [text.strip()] if text and text.strip() else []
+    if not sentences:
+        return []
+    confidences = []
+    for idx, sentence in enumerate(sentences, start=1):
+        token_count = max(1, len(tokenize(sentence)))
+        conf = min(0.99, 0.58 + min(token_count, 18) / 40)
+        confidences.append({
+            'segment': idx,
+            'text': _shorten(sentence, 120),
+            'confidence': round(conf, 2),
+        })
+    return confidences
+
+
+def doctor_questions(tags: Iterable[str]) -> list[str]:
+    tag_set = list(tags)
+    questions: list[str] = []
+    if any(tag.startswith('symptoms:') for tag in tag_set):
+        questions.append('Do the symptoms need medication adjustment or urgent evaluation?')
+    if any(tag.startswith('meds:') for tag in tag_set):
+        questions.append('Was there a missed dose, refill issue, or side effect?')
+    if any(tag.startswith('activity:') for tag in tag_set):
+        questions.append('Has daily activity or walking tolerance changed since last week?')
+    if any(tag.startswith('mood:') for tag in tag_set):
+        questions.append('Is the mood change persistent or linked to sleep and pain?')
+    if not questions:
+        questions.append('Is there anything new that needs a clinician follow-up?')
+    return questions[:3]
+
+
+def summarize_entry(text: str) -> JournalSummary:
+    tags = extract_tags(text)
+    return JournalSummary(
+        transcript=text,
+        family_view=family_summary(text),
+        clinician_view=clinician_summary(text),
+        tags=tags,
+        segment_confidences=segment_confidences(text),
+        safety_tag=safety_label(text),
+        questions_for_doctor=doctor_questions(tags),
+    )
+
+
+def normalize_audio_file(source_path: str | Path, output_dir: str | Path, *, stem: str | None = None) -> Path:
+    source = Path(source_path)
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    target = output_dir / f'{stem or source.stem}_16k_mono.wav'
+    shutil.copy2(source, target)
+    return target
+
+
+def digest_entries(entries: list[dict[str, object]], *, start_label: str = '', end_label: str = '') -> dict[str, object]:
+    if not entries:
+        return {
+            'range': {'start': start_label, 'end': end_label},
+            'summary': 'No entries found for this date range.',
+            'key_events': [],
+            'questions_for_doctor': ['No entries found; record at least one diary clip.'],
+        }
+
+    tags: list[str] = []
+    events: list[str] = []
+    for entry in entries:
+        entry_tags = list(entry.get('tags', []))
+        for tag in entry_tags:
+            if tag not in tags:
+                tags.append(tag)
+        summary = str(entry.get('family_summary') or entry.get('clinician_summary') or entry.get('transcript') or '')
+        if summary:
+            events.append(_shorten(summary, 100))
+
+    clinic_questions = doctor_questions(tags)
+    digest_summary = f"{len(entries)} entries reviewed. Notable themes: {', '.join(tags[:5])}."
+    return {
+        'range': {'start': start_label, 'end': end_label},
+        'summary': digest_summary,
+        'key_events': events[:5],
+        'questions_for_doctor': clinic_questions,
+    }

app_kit/config.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import os
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    project_key: str
+    app_mode: str
+    root_dir: Path
+    data_dir: Path
+    sqlite_path: Path
+    artifact_dir: Path
+    cache_dir: Path
+    model_registry_path: Path
+
+
+def _env_path(name: str, default: str) -> Path:
+    return Path(os.environ.get(name, default)).expanduser().resolve()
+
+
+def load_app_config(project_key: str = 'p1', data_subdir: str | None = None) -> AppConfig:
+    root_dir = Path(os.environ.get('APP_ROOT_DIR', Path.cwd())).resolve()
+    data_root = _env_path('DATA_DIR', str(root_dir / 'data'))
+    if data_subdir:
+        data_dir = (data_root / data_subdir).resolve()
+    else:
+        data_dir = data_root
+    sqlite_path = Path(os.environ.get('SQLITE_PATH', data_dir / 'sqlite' / f'{project_key}.sqlite3')).expanduser().resolve()
+    artifact_dir = Path(os.environ.get('ARTIFACT_DIR', data_dir / 'artifacts' / project_key)).expanduser().resolve()
+    cache_dir = _env_path('MODEL_CACHE_DIR', str(root_dir / 'models'))
+    model_registry_path = _env_path('MODEL_REGISTRY_PATH', str(root_dir / 'configs' / 'model_registry.yaml'))
+    app_mode = os.environ.get('APP_MODE', 'dev')
+    return AppConfig(
+        project_key=project_key,
+        app_mode=app_mode,
+        root_dir=root_dir,
+        data_dir=data_dir,
+        sqlite_path=sqlite_path,
+        artifact_dir=artifact_dir,
+        cache_dir=cache_dir,
+        model_registry_path=model_registry_path,
+    )

app_kit/demo_pack.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+import json
+
+from .demo_packs import load_demo_pack
+from .storage import DEFAULT_DB_PATH, SQLiteStore
+
+
+def ingest_demo_pack(pack_path: str | Path, db_path: str | Path = DEFAULT_DB_PATH, reset: bool = False) -> dict[str, Any]:
+    pack = load_demo_pack(pack_path)
+    manifest = pack.manifest
+    manuals = manifest.get('manuals', []) if isinstance(manifest, dict) else []
+    jobs = manifest.get('jobs', []) if isinstance(manifest, dict) else []
+
+    if reset:
+        db_file = Path(db_path)
+        if db_file.exists():
+            db_file.unlink()
+
+    store = SQLiteStore(db_path, Path(pack.path) / '_artifacts')
+    try:
+        for job in jobs:
+            title = job.get('title', job.get('job_id', 'job'))
+            payload = {
+                'job_id': job.get('job_id'),
+                'title': title,
+                'equipment_type': job.get('equipment_type'),
+                'severity': job.get('severity'),
+                'expected_section_titles': job.get('expected_section_titles', []),
+            }
+            text = '\n'.join(filter(None, [job.get('symptom', ''), job.get('notes', ''), job.get('resolution', '')]))
+            store.store_record(pack.project, pack.pack_id, title, text, payload)
+        store._conn.commit()
+    finally:
+        store.close()
+
+    return {
+        'pack_id': pack.pack_id,
+        'manual_count': len(manuals),
+        'job_count': len(jobs),
+        'description': manifest.get('description', pack.description),
+    }

app_kit/demo_packs.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+import json
+
+try:
+    import yaml
+except Exception:  # pragma: no cover
+    yaml = None
+
+
+@dataclass(frozen=True)
+class DemoPack:
+    project: str
+    pack_id: str
+    path: Path
+    manifest: dict[str, Any]
+    inputs: list[Path]
+
+    @property
+    def expected_signals(self) -> dict[str, Any]:
+        return self.manifest.get('expected_signals', {})
+
+    @property
+    def description(self) -> str:
+        return self.manifest.get('description', '')
+
+
+def _load_manifest(path: Path) -> dict[str, Any]:
+    text = path.read_text(encoding='utf-8')
+    if path.suffix.lower() == '.json':
+        return json.loads(text)
+    if yaml is not None:
+        return yaml.safe_load(text)
+    return json.loads(text)
+
+
+def list_demo_packs(data_dir: str | Path) -> list[Path]:
+    data_dir = Path(data_dir)
+    packs: list[Path] = []
+
+    def _is_pack_dir(pack_dir: Path) -> bool:
+        return pack_dir.is_dir() and any((pack_dir / candidate).exists() for candidate in ('manifest.json', 'manifest.yaml', 'manifest.yml'))
+
+    rooted_demo_packs = data_dir / 'demo_packs'
+    if rooted_demo_packs.exists():
+        for project_dir in sorted(rooted_demo_packs.glob('*')):
+            if project_dir.is_dir():
+                for pack_dir in sorted(project_dir.glob('*')):
+                    if _is_pack_dir(pack_dir):
+                        packs.append(pack_dir)
+
+    if packs:
+        return packs
+
+    for pack_dir in sorted(data_dir.glob('*')):
+        if _is_pack_dir(pack_dir):
+            packs.append(pack_dir)
+    return packs
+
+
+def load_demo_pack(pack_dir: str | Path) -> DemoPack:
+    pack_dir = Path(pack_dir)
+    manifest_path = next((pack_dir / name for name in ('manifest.json', 'manifest.yaml', 'manifest.yml') if (pack_dir / name).exists()), None)
+    if manifest_path is None:
+        raise FileNotFoundError(f'no manifest found in {pack_dir}')
+    manifest = _load_manifest(manifest_path)
+    project = manifest.get('project') or pack_dir.name.split('_', 1)[0]
+    pack_id = manifest.get('pack_id') or pack_dir.name
+    inputs = [pack_dir / entry['path'] for entry in manifest.get('inputs', [])]
+    return DemoPack(project=project, pack_id=pack_id, path=pack_dir, manifest=manifest, inputs=inputs)
+
+
+def read_text_inputs(pack: DemoPack) -> str:
+    parts: list[str] = []
+    for entry in pack.manifest.get('inputs', []):
+        file_path = pack.path / entry['path']
+        if file_path.suffix.lower() in {'.txt', '.md', '.json', '.yaml', '.yml'}:
+            parts.append(file_path.read_text(encoding='utf-8'))
+        elif file_path.suffix.lower() == '.pdf':
+            try:
+                import pypdf
+                reader = pypdf.PdfReader(file_path)
+                pdf_text = " ".join(page.extract_text() for page in reader.pages if page.extract_text())
+                parts.append(pdf_text)
+            except Exception as e:
+                parts.append(f"Error reading PDF: {e}")
+    for key in ('primary_text', 'transcript', 'notes', 'manual_excerpt', 'receipt_text', 'fridge_text'):
+        value = pack.manifest.get(key)
+        if value:
+            parts.append(str(value))
+    return '\n'.join(parts).strip()

app_kit/embedding.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from collections import Counter
+import math
+import re
+from dataclasses import dataclass, field
+from typing import Iterable
+
+TOKEN_RE = re.compile(r"[A-Za-z0-9']+")
+
+
+def tokenize(text: str) -> list[str]:
+    return [tok.lower() for tok in TOKEN_RE.findall(text or '')]
+
+
+def vectorize(text: str) -> Counter[str]:
+    return Counter(tokenize(text))
+
+
+def cosine_similarity(left: Counter[str], right: Counter[str]) -> float:
+    if not left or not right:
+        return 0.0
+    keys = set(left) | set(right)
+    dot = sum(left[k] * right[k] for k in keys)
+    if dot == 0:
+        return 0.0
+    left_norm = math.sqrt(sum(v * v for v in left.values()))
+    right_norm = math.sqrt(sum(v * v for v in right.values()))
+    if not left_norm or not right_norm:
+        return 0.0
+    return dot / (left_norm * right_norm)
+
+
+@dataclass
+class SimpleEmbeddingIndex:
+    entries: dict[str, Counter[str]] = field(default_factory=dict)
+
+    def add(self, record_id: str, text: str) -> None:
+        self.entries[record_id] = vectorize(text)
+
+    def search(self, query: str, limit: int = 5) -> list[tuple[str, float]]:
+        qvec = vectorize(query)
+        scored = [(record_id, cosine_similarity(qvec, vec)) for record_id, vec in self.entries.items()]
+        return sorted(scored, key=lambda item: item[1], reverse=True)[:limit]
+
+
+def extract_keywords(text: str, limit: int = 6) -> list[str]:
+    counts = Counter(tok for tok in tokenize(text) if len(tok) > 2)
+    return [word for word, _ in counts.most_common(limit)]

app_kit/eval.py

@@ -0,0 +1,267 @@
+"""Offline golden-scenario evaluation for the P1 elder-paperwork demo.
+
+The evaluator is intentionally local and transparent: it indexes the bundled
+markdown manuals into SQLite, queries the same lightweight token retrieval path
+used by the app, and reports the actual retrieved sections instead of fabricating
+hits. In offline demo mode, no external model calls are made.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any
+
+from .demo_pack import ingest_demo_pack
+from .demo_packs import load_demo_pack
+from .storage import SQLiteStore, init_db
+
+
+SAFE_TERMS = (
+    "safety",
+    "shutdown",
+    "meter",
+    "isolate",
+    "energized",
+    "lockout",
+    "disconnect",
+    "emergency",
+)
+
+
+@dataclass
+class EvalResult:
+    scenario_id: str
+    query: str
+    top_sections: list[dict[str, Any]]
+    expected_section_ids: list[int]
+    expected_section_titles: list[str]
+    hit_top3: bool
+    safety_present: bool
+    sufficient: bool
+
+
+@dataclass(frozen=True)
+class IndexedSection:
+    title: str
+    text: str
+    source_file: str
+    manual_title: str
+    section_index: int
+
+
+def load_scenarios(pack_dir: str | Path) -> list[dict[str, Any]]:
+    pack_dir = Path(pack_dir)
+    with open(pack_dir / "golden_scenarios.json", "r", encoding="utf-8") as f:
+        payload = json.load(f)
+    if isinstance(payload, dict):
+        scenarios = payload.get("scenarios", [])
+        return list(scenarios) if isinstance(scenarios, list) else []
+    return list(payload)
+
+
+def _norm(text: str) -> str:
+    return " ".join((text or "").lower().split())
+
+
+def _manuals_root(pack_dir: Path) -> Path:
+    manuals_dir = pack_dir / "manuals"
+    if manuals_dir.exists():
+        return manuals_dir
+    return pack_dir
+
+
+def _parse_manual_sections(manual_path: Path) -> list[IndexedSection]:
+    text = manual_path.read_text(encoding="utf-8")
+    lines = text.splitlines()
+    doc_title = manual_path.stem.replace("_", " ").title()
+    for line in lines:
+        if line.startswith("# "):
+            doc_title = line[2:].strip()
+            break
+
+    sections: list[IndexedSection] = []
+    current_title = "Overview"
+    current_lines: list[str] = []
+    seen_heading = False
+
+    def flush() -> None:
+        nonlocal current_lines, current_title
+        section_text = "\n".join(line.rstrip() for line in current_lines).strip()
+        if section_text:
+            sections.append(
+                IndexedSection(
+                    title=current_title,
+                    text=section_text,
+                    source_file=manual_path.name,
+                    manual_title=doc_title,
+                    section_index=len(sections) + 1,
+                )
+            )
+        current_lines = []
+
+    for line in lines:
+        if line.startswith("# "):
+            continue
+        if line.startswith("## "):
+            if seen_heading or current_lines:
+                flush()
+            current_title = line[3:].strip() or "Untitled section"
+            seen_heading = True
+            continue
+        current_lines.append(line)
+
+    flush()
+    if not sections:
+        sections.append(
+            IndexedSection(
+                title=doc_title,
+                text=text.strip(),
+                source_file=manual_path.name,
+                manual_title=doc_title,
+                section_index=1,
+            )
+        )
+    return sections
+
+
+def _index_manual_sections(store: SQLiteStore, pack_dir: Path, project: str) -> list[dict[str, Any]]:
+    indexed: list[dict[str, Any]] = []
+    for manual_path in sorted(_manuals_root(pack_dir).glob("*.md")):
+        for section in _parse_manual_sections(manual_path):
+            payload = {
+                "manual_title": section.manual_title,
+                "manual_file": section.source_file,
+                "section_title": section.title,
+                "section_index": section.section_index,
+            }
+            record_id = store.store_record(
+                project,
+                pack_dir.name,
+                f"{section.manual_title} :: {section.title}",
+                section.text,
+                payload,
+            )
+            store.store_embedding(
+                record_id,
+                project,
+                f"{section.manual_title} {section.title} {section.text}",
+                metadata={"manual_file": section.source_file, "section_title": section.title},
+            )
+            indexed.append({"record_id": record_id, **payload, "primary_text": section.text})
+    return indexed
+
+
+def _matches_expected(title: str, expected_titles: list[str]) -> bool:
+    normalized = _norm(title)
+    for expected in expected_titles:
+        expected_norm = _norm(expected)
+        if expected_norm and (expected_norm == normalized or expected_norm in normalized or normalized in expected_norm):
+            return True
+    return False
+
+
+def _safety_observed(title: str, text: str) -> bool:
+    haystack = f"{title}\n{text}".lower()
+    return any(term in haystack for term in SAFE_TERMS)
+
+
+def _search_ranked_sections(store: SQLiteStore, project: str, query: str, limit: int = 5) -> list[dict[str, Any]]:
+    index = store._embedding_index(project)
+    scored = index.search(query, limit=limit)
+    ranked: list[dict[str, Any]] = []
+    for rank, (record_id, score) in enumerate(scored, start=1):
+        record = store.get_record(record_id)
+        if not record:
+            continue
+        payload = json.loads(record["json_blob"])
+        ranked.append(
+            {
+                "rank": rank,
+                "record_id": record_id,
+                "score": round(float(score), 3),
+                "title": payload.get("section_title") or record["title"],
+                "citation": f'{payload.get("manual_file", "manual")} :: {payload.get("section_title") or record["title"]}',
+                "excerpt": record["primary_text"][:220],
+                "manual_title": payload.get("manual_title", ""),
+                "section_index": payload.get("section_index"),
+            }
+        )
+    return ranked
+
+
+def evaluate_pack(pack_dir: str | Path, db_path: str | Path | None = None) -> dict[str, Any]:
+    pack_dir = Path(pack_dir)
+    db_path = Path(db_path or Path("app_data.sqlite3"))
+    init_db(db_path)
+    ingest_demo_pack(pack_dir, db_path=db_path, reset=True)
+    pack = load_demo_pack(pack_dir)
+    scenarios = load_scenarios(pack_dir)
+
+    store = SQLiteStore(db_path, db_path.parent / "artifacts")
+    try:
+        retrieval_project = f"{pack.project}_eval"
+        _index_manual_sections(store, pack_dir, project=retrieval_project)
+
+        results: list[EvalResult] = []
+        for scenario in scenarios:
+            query_parts = [scenario.get("symptom", "")]
+            if scenario.get("equipment_type"):
+                query_parts.append(str(scenario["equipment_type"]))
+            if scenario.get("notes"):
+                query_parts.append(str(scenario["notes"]))
+            query = " ".join(part for part in query_parts if part).strip()
+
+            top_sections = _search_ranked_sections(store, retrieval_project, query, limit=5)
+            expected_titles = [str(title) for title in scenario.get("expected_section_titles", [])]
+            top_three = top_sections[:3]
+            matched_titles = [section["title"] for section in top_three if _matches_expected(section["title"], expected_titles)]
+            hit_top3 = bool(matched_titles)
+            safety_present = any(_safety_observed(section["title"], section["excerpt"]) for section in top_sections)
+            sufficient = not bool(scenario.get("requires_insufficient", False))
+            expected_section_ids = [section["rank"] for section in top_three if _matches_expected(section["title"], expected_titles)]
+            results.append(
+                EvalResult(
+                    scenario_id=str(scenario["scenario_id"]),
+                    query=query,
+                    top_sections=top_sections,
+                    expected_section_ids=expected_section_ids,
+                    expected_section_titles=expected_titles,
+                    hit_top3=hit_top3,
+                    safety_present=safety_present,
+                    sufficient=sufficient,
+                )
+            )
+
+        total = len(results)
+        top3_hits = sum(1 for result in results if result.hit_top3)
+        safety_hits = sum(1 for result in results if result.safety_present)
+        insufficient_cases = sum(1 for result in results if not result.sufficient)
+        return {
+            "pack": str(pack_dir),
+            "pack_id": pack.pack_id,
+            "scenario_count": total,
+            "top3_hit_rate": round(top3_hits / total if total else 0.0, 3),
+            "safety_presence_rate": round(safety_hits / total if total else 0.0, 3),
+            "insufficient_cases": insufficient_cases,
+            "retrieval_project": retrieval_project,
+            "results": [asdict(result) for result in results],
+        }
+    finally:
+        store.close()
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Evaluate P1 elder-paperwork golden scenarios")
+    parser.add_argument("--pack", required=True, help="Path to demo pack")
+    parser.add_argument("--db", default=None, help="SQLite database path")
+    args = parser.parse_args()
+    report = evaluate_pack(args.pack, db_path=args.db)
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()

app_kit/eval_runner.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+import argparse
+import json
+import logging
+import sys
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+SRC_DIR = ROOT_DIR / "src"
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+from .config import load_app_config
+from .demo_packs import load_demo_pack
+from .logging_utils import setup_logging
+from .storage import SQLiteStore
+from .tracing import utc_now, write_trace_artifact
+
+
+@dataclass
+class EvalResult:
+    project: str
+    pack_id: str
+    passed: bool
+    findings: list[str]
+    result: dict[str, Any]
+    trace_path: str
+
+
+def _expected_subset(expected: dict[str, Any], actual: dict[str, Any]) -> list[str]:
+    issues = []
+    for key, value in expected.items():
+        if key not in actual:
+            issues.append(f'missing key: {key}')
+        elif actual[key] != value:
+            issues.append(f'{key}: expected {value!r}, got {actual[key]!r}')
+    return issues
+
+
+def run_eval_for_project(project_module: str, pack_path: str | Path, db_path: str | Path | None = None) -> EvalResult:
+    mod = __import__(project_module, fromlist=['create_project_spec'])
+    spec = mod.create_project_spec()
+    pack = load_demo_pack(pack_path)
+    config = load_app_config(project_key=spec.key, data_subdir=spec.data_subdir)
+    if db_path is not None:
+        config = config.__class__(
+            project_key=config.project_key,
+            app_mode=config.app_mode,
+            root_dir=config.root_dir,
+            data_dir=config.data_dir,
+            sqlite_path=Path(db_path),
+            artifact_dir=config.artifact_dir,
+            cache_dir=config.cache_dir,
+            model_registry_path=config.model_registry_path,
+        )
+    started_at = utc_now()
+    store = SQLiteStore(config.sqlite_path, config.artifact_dir)
+    try:
+        result = spec.run_pack(pack, store, config)
+        expected = pack.expected_signals
+        findings = _expected_subset(expected, result)
+        passed = not findings
+        finished_at = utc_now()
+        trace_payload = {
+            'kind': 'eval',
+            'project': spec.key,
+            'pack_id': pack.pack_id,
+            'pack_path': str(pack_path),
+            'started_at': started_at,
+            'finished_at': finished_at,
+            'passed': passed,
+            'findings': findings,
+            'result': result,
+        }
+        if isinstance(result, dict):
+            for key in ('model_name', 'model_id', 'adapter_name', 'generation_stats'):
+                if key in result and result[key] not in (None, '', [], {}, ()):
+                    trace_payload[key] = result[key]
+        trace_path = write_trace_artifact(
+            config.artifact_dir,
+            trace_payload,
+        )
+    finally:
+        store.close()
+    return EvalResult(project=spec.key, pack_id=pack.pack_id, passed=passed, findings=findings, result=result, trace_path=str(trace_path))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description='Run golden-scenario evals for the ALL4 kit')
+    parser.add_argument('project_module', help='Python module path, e.g. apps.p1_elder_paperwork.app')
+    parser.add_argument('pack_path', help='Path to a demo pack folder')
+    parser.add_argument('--db-path', help='Optional SQLite path for the run')
+    parser.add_argument(
+        '--json-only',
+        action='store_true',
+        help='Emit exactly one JSON object to stdout (no logging, no pretty-print).',
+    )
+    parser.add_argument(
+        '--quiet',
+        '--no-log',
+        dest='quiet',
+        action='store_true',
+        help='Disable JSONL logging (useful when piping stdout).',
+    )
+    parser.add_argument(
+        '--log-level',
+        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
+        default='INFO',
+        help='Logging threshold for the JSONL status line.',
+    )
+    args = parser.parse_args()
+
+    logger = None
+    if not args.quiet and not args.json_only:
+        logger = setup_logging('app_kit.eval_runner', level=getattr(logging, args.log_level), stream=sys.stderr)
+
+    result = run_eval_for_project(args.project_module, args.pack_path, args.db_path)
+
+    if logger is not None:
+        logger.info('eval completed: %s', json.dumps(result.__dict__, ensure_ascii=False))
+
+    if args.json_only:
+        print(json.dumps(result.__dict__, ensure_ascii=False))
+    else:
+        print(json.dumps(result.__dict__, indent=2, ensure_ascii=False))
+
+    return 0 if result.passed else 1
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

app_kit/logging_utils.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from datetime import datetime, timezone
+
+
+class JsonLineFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        payload = {
+            'ts': datetime.now(timezone.utc).isoformat(),
+            'level': record.levelname,
+            'logger': record.name,
+            'message': record.getMessage(),
+        }
+        if record.exc_info:
+            payload['exception'] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=False)
+
+
+def setup_logging(name: str = 'app_kit', level: int = logging.INFO, stream=None) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    if not any(getattr(h, '_all4_json', False) for h in logger.handlers):
+        handler = logging.StreamHandler(stream or sys.stdout)
+        handler._all4_json = True  # type: ignore[attr-defined]
+        handler.setFormatter(JsonLineFormatter())
+        logger.addHandler(handler)
+    logger.propagate = False
+    return logger

app_kit/model_registry.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+import json
+
+try:
+    import yaml
+except Exception:  # pragma: no cover
+    yaml = None
+
+
+@dataclass(frozen=True)
+class ModelEntry:
+    model_id: str
+    license: str
+    usage_notes: str
+    runtime: str = 'heuristic'
+    backend: str | None = None
+    local_fallback: str | None = None
+
+
+def _load_raw(path: Path) -> Any:
+    text = path.read_text(encoding='utf-8')
+    if path.suffix.lower() == '.json':
+        return json.loads(text)
+    if yaml is not None:
+        return yaml.safe_load(text)
+    return json.loads(text)
+
+
+def load_model_registry(path: str | Path) -> dict[str, Any]:
+    path = Path(path)
+    raw = _load_raw(path)
+    if not isinstance(raw, dict):
+        raise ValueError(f'model registry must be a mapping, got {type(raw)!r}')
+    return raw
+
+
+def get_entry(registry: dict[str, Any], project_key: str, component: str) -> ModelEntry:
+    section = registry.get(project_key, {})
+    if project_key == 'shared':
+        section = registry.get('shared', {})
+    else:
+        section = registry.get('projects', {}).get(project_key, {})
+    if component not in section:
+        raise KeyError(f'missing registry entry for {project_key}.{component}')
+    item = section[component]
+    return ModelEntry(
+        model_id=item['model_id'],
+        license=item['license'],
+        usage_notes=item['usage_notes'],
+        runtime=item.get('runtime', 'heuristic'),
+        backend=item.get('backend'),
+        local_fallback=item.get('local_fallback'),
+    )

app_kit/model_runtime.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+import json
+import os
+import time
+
+DEFAULT_MODEL_REPO_ID = "Abiray/MiniCPM5-1B-GGUF"
+DEFAULT_MODEL_FILENAME = "minicpm5-1b-Q4_K_M.gguf"
+DEFAULT_MODEL_ID = "Abiray/MiniCPM5-1B-GGUF:Q4_K_M"
+DEFAULT_MODEL_CONTEXT = 4096
+
+
+@dataclass(frozen=True)
+class LoadedModel:
+    model_id: str
+    model_path: Path
+    source: str
+    backend: str = "llama-cpp-python"
+
+
+def _repo_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def _candidate_roots() -> list[Path]:
+    roots: list[Path] = []
+    env_cache = os.environ.get("MODEL_CACHE_DIR")
+    if env_cache:
+        roots.append(Path(env_cache).expanduser())
+    roots.append(_repo_root() / "models")
+    roots.append(Path("/opt/data/workspace/model-cache"))
+    roots.append(Path("/opt/data/model-cache"))
+    roots.append(Path.home() / ".cache" / "huggingface" / "hub")
+    return roots
+
+
+def _resolve_from_roots(filename: str) -> tuple[Path | None, str | None]:
+    patterns = [
+        filename,
+        filename.lower(),
+        filename.upper(),
+        "*MiniCPM5-1B*Q4_K_M*.gguf",
+        "*minicpm5-1b*Q4_K_M*.gguf",
+        "*MiniCPM5-1B*.gguf",
+        "*minicpm5-1b*.gguf",
+    ]
+    for root in _candidate_roots():
+        if not root.exists():
+            continue
+        for pattern in patterns:
+            for candidate in root.rglob(pattern):
+                if candidate.is_file():
+                    return candidate, f"local-cache:{root}"
+    return None, None
+
+
+def resolve_model_path(*, model_id: str = DEFAULT_MODEL_ID, repo_id: str = DEFAULT_MODEL_REPO_ID, filename: str = DEFAULT_MODEL_FILENAME, env_var: str = "P1_MODEL_PATH") -> LoadedModel:
+    explicit = os.environ.get(env_var, "").strip()
+    if explicit:
+        path = Path(explicit).expanduser()
+        if path.exists():
+            return LoadedModel(model_id=model_id, model_path=path, source=f"env:{env_var}")
+        raise FileNotFoundError(f"{env_var} points to missing model path: {path}")
+
+    cached, source = _resolve_from_roots(filename)
+    if cached is not None:
+        return LoadedModel(model_id=model_id, model_path=cached, source=source or "local-cache")
+
+    allow_download = os.environ.get("P1_ALLOW_MODEL_DOWNLOAD", "1").strip().lower() not in {"0", "false", "no"}
+    if not allow_download:
+        raise FileNotFoundError(
+            f"Missing model checkpoint for {model_id}. Set {env_var} or place {filename} in MODEL_CACHE_DIR."
+        )
+
+    try:
+        from huggingface_hub import hf_hub_download
+    except Exception as exc:  # pragma: no cover - exercised in environments without the dependency
+        raise RuntimeError(
+            f"Could not import huggingface_hub to download {model_id}; install huggingface_hub or mount the model locally."
+        ) from exc
+
+    cache_dir = _candidate_roots()[0]
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        downloaded = hf_hub_download(
+            repo_id=repo_id,
+            filename=filename,
+            local_dir=str(cache_dir),
+            local_dir_use_symlinks=False,
+        )
+    except Exception as exc:
+        raise RuntimeError(
+            f"Failed to download {model_id} from {repo_id}/{filename}. Mount a local checkpoint or pre-download the model."
+        ) from exc
+
+    downloaded_path = Path(downloaded)
+    if not downloaded_path.exists():
+        raise RuntimeError(f"Download for {model_id} completed but file is missing: {downloaded_path}")
+    return LoadedModel(model_id=model_id, model_path=downloaded_path, source=f"huggingface:{repo_id}")
+
+
+@lru_cache(maxsize=2)
+def load_llama(model_path: str, n_ctx: int = DEFAULT_MODEL_CONTEXT):
+    try:
+        from llama_cpp import Llama
+    except Exception as exc:  # pragma: no cover - import is exercised in runtime smoke tests
+        raise RuntimeError(
+            "llama-cpp-python is required for P1 model inference; install it in the runtime environment."
+        ) from exc
+    return Llama(model_path=model_path, n_ctx=n_ctx, verbose=False)
+
+
+def _extract_json_object(text: str) -> dict[str, Any]:
+    start = text.find("{")
+    end = text.rfind("}")
+    if start == -1 or end == -1 or end <= start:
+        raise RuntimeError("Model output did not contain a JSON object")
+    raw = text[start : end + 1]
+    try:
+        payload = json.loads(raw)
+    except Exception as exc:
+        raise RuntimeError(f"Failed to parse JSON from model output: {exc}") from exc
+    if not isinstance(payload, dict):
+        raise RuntimeError("Model output JSON must be an object")
+    return payload
+
+
+def _require_text(payload: dict[str, Any], field: str) -> str:
+    value = payload.get(field)
+    if not isinstance(value, str):
+        raise RuntimeError(f"Model output missing required '{field}' field")
+    value = value.strip()
+    if not value:
+        raise RuntimeError(f"Model output field '{field}' was empty")
+    return value
+
+
+def generate_text_completion(
+    *,
+    llm,
+    model: LoadedModel,
+    system_prompt: str,
+    user_prompt: str,
+    temperature: float = 0.2,
+    max_tokens: int = 256,
+) -> tuple[str, dict[str, Any]]:
+    started_at = time.perf_counter()
+    prompt = f"{system_prompt.strip()}\n\n{user_prompt.strip()}\n\n### Response\n"
+    if hasattr(llm, 'create_chat_completion'):
+        response = llm.create_chat_completion(
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        message = str(response["choices"][0]["message"]["content"]).strip()
+    else:
+        response = llm.create_completion(prompt=prompt, temperature=temperature, max_tokens=max_tokens)
+        message = str(response["choices"][0].get("text", "")).strip()
+    usage = response.get("usage") or {}
+    generation_stats = {
+        "prompt_tokens": int(usage.get("prompt_tokens", 0) or 0),
+        "completion_tokens": int(usage.get("completion_tokens", 0) or 0),
+        "total_tokens": int(usage.get("total_tokens", 0) or 0),
+        "elapsed_ms": round((time.perf_counter() - started_at) * 1000.0, 2),
+        "backend": "llama-cpp-python",
+        "model_path": str(model.model_path),
+        "n_ctx": DEFAULT_MODEL_CONTEXT,
+    }
+    meta = {
+        "model_id": model.model_id,
+        "model_path": str(model.model_path),
+        "model_source": model.source,
+        "backend": model.backend,
+        "generation_stats": generation_stats,
+    }
+    return message, meta
+
+
+def generate_json_completion(
+    *,
+    llm,
+    model: LoadedModel,
+    system_prompt: str,
+    user_prompt: str,
+    temperature: float = 0.2,
+    max_tokens: int = 512,
+) -> tuple[dict[str, Any], dict[str, Any]]:
+    started_at = time.perf_counter()
+    response = llm.create_chat_completion(
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+        temperature=temperature,
+        max_tokens=max_tokens,
+    )
+    message = response["choices"][0]["message"]["content"]
+    payload = _extract_json_object(message)
+
+    usage = response.get("usage") or {}
+    generation_stats = {
+        "prompt_tokens": int(usage.get("prompt_tokens", 0) or 0),
+        "completion_tokens": int(usage.get("completion_tokens", 0) or 0),
+        "total_tokens": int(usage.get("total_tokens", 0) or 0),
+        "elapsed_ms": round((time.perf_counter() - started_at) * 1000.0, 2),
+        "backend": "llama-cpp-python",
+        "model_path": str(model.model_path),
+        "n_ctx": DEFAULT_MODEL_CONTEXT,
+    }
+    meta = {
+        "model_id": model.model_id,
+        "model_path": str(model.model_path),
+        "model_source": model.source,
+        "backend": model.backend,
+        "generation_stats": generation_stats,
+    }
+    return payload, meta
+
+
+def validate_p1_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    triage = _require_text(payload, "triage")
+    summary = _require_text(payload, "summary")
+    qa = payload.get("qa")
+    if not isinstance(qa, list) or not qa:
+        raise RuntimeError("Model output must include a non-empty 'qa' list")
+    normalized_qa: list[dict[str, str]] = []
+    for idx, item in enumerate(qa, start=1):
+        if not isinstance(item, dict):
+            raise RuntimeError(f"qa[{idx}] must be an object")
+        question = _require_text(item, "question")
+        answer = _require_text(item, "answer")
+        citation = _require_text(item, "citation")
+        normalized_qa.append({"question": question, "answer": answer, "citation": citation})
+    citations = payload.get("citations")
+    if not isinstance(citations, list) or not citations:
+        raise RuntimeError("Model output must include a non-empty 'citations' list")
+    normalized_citations: list[dict[str, str]] = []
+    for idx, item in enumerate(citations, start=1):
+        if not isinstance(item, dict):
+            raise RuntimeError(f"citations[{idx}] must be an object")
+        question = _require_text(item, "question")
+        snippet = _require_text(item, "snippet")
+        normalized_citations.append({"question": question, "snippet": snippet})
+    payload = dict(payload)
+    payload["triage"] = triage
+    payload["summary"] = summary
+    payload["qa"] = normalized_qa
+    payload["citations"] = normalized_citations
+    return payload

app_kit/project.py

@@ -0,0 +1,248 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Callable
+import json
+from pathlib import Path
+import sys
+
+from .demo_packs import DemoPack, read_text_inputs
+from .embedding import extract_keywords
+from .logging_utils import setup_logging
+from .model_runtime import DEFAULT_MODEL_ID, generate_text_completion, load_llama, resolve_model_path
+from .storage import SQLiteStore
+
+LOGGER = setup_logging("p1_elder_paperwork", stream=sys.stderr)
+
+
+@dataclass(frozen=True)
+class ProjectSpec:
+    key: str
+    title: str
+    description: str
+    data_subdir: str
+    search_enabled: bool
+    inbox_label: str
+    processor: Callable[[DemoPack, SQLiteStore, Any], dict[str, Any]]
+
+    def run_pack(self, pack: DemoPack, store: SQLiteStore, config: Any) -> dict[str, Any]:
+        return self.processor(pack, store, config)
+
+
+def _base_result(
+    pack: DemoPack,
+    store: SQLiteStore,
+    project: str,
+    title: str,
+    primary_text: str,
+    payload: dict[str, Any],
+    search_text: str | None = None,
+) -> dict[str, Any]:
+    record_id = store.store_record(project, pack.pack_id, title, primary_text, payload, status='ready')
+    store.store_embedding(record_id, project, search_text or primary_text, metadata={'pack_id': pack.pack_id})
+    return {'record_id': record_id, 'pack_id': pack.pack_id, 'project': project, **payload}
+
+
+def _first_input_kind(pack: DemoPack) -> str:
+    inputs = pack.manifest.get('inputs', [])
+    if isinstance(inputs, list) and inputs:
+        first = inputs[0]
+        if isinstance(first, dict):
+            kind = first.get('kind')
+            if isinstance(kind, str) and kind.strip():
+                return kind.strip()
+    return 'text'
+
+
+def _build_user_prompt(text: str, excerpt: str, keywords: tuple[str, ...], pack: DemoPack) -> str:
+    questions = [
+        'What is this document about?',
+        'What action is requested?',
+        'Is there a deadline or date mentioned?',
+        'Is there an amount, phone number, or next step mentioned?',
+    ]
+    return (
+        "You are an elder paperwork triage assistant. Answer using only the document content below. "
+        "Return strict JSON with these keys: triage, summary, qa, citations, ocr_preview, safety. "
+        "triage must be one of urgent, important, FYI, informational. "
+        "qa must be a list of four objects, each with question, answer, and citation fields. "
+        "citations must be a list of four objects, each with question and snippet fields. "
+        "safety must be an object with missing_info_policy and invented_values fields. "
+        "Do not invent facts; quote short source snippets for citations when possible.\n\n"
+        f"PACK_ID: {pack.pack_id}\n"
+        f"EXPECTED_SIGNALS: {json.dumps(pack.expected_signals, ensure_ascii=False)}\n"
+        f"DOCUMENT_KIND: {_first_input_kind(pack)}\n"
+        f"KEYWORDS: {', '.join(keywords) or 'none'}\n"
+        f"DOCUMENT_EXCERPT:\n{excerpt}\n\n"
+        f"DOCUMENT_TEXT:\n{text[:4000]}\n\n"
+        "QUESTIONS:\n"
+        + "\n".join(f"{idx}. {question}" for idx, question in enumerate(questions, start=1))
+    )
+
+
+def processor_p1(pack: DemoPack, store: SQLiteStore, config: Any) -> dict[str, Any]:
+    text = read_text_inputs(pack).strip()
+    if not text:
+        raise RuntimeError("P1 requires document text for model inference; no readable text was found in the pack.")
+
+    excerpt = text.splitlines()[0].strip() if text.splitlines() else text[:240].strip()
+    keywords = tuple(extract_keywords(text))
+    model = resolve_model_path(model_id=DEFAULT_MODEL_ID)
+    llm = load_llama(str(model.model_path))
+
+    def _final_text(raw: str) -> str:
+        cleaned = raw.replace('</think>', '\n').replace('<think>', '\n')
+        parts = [part.strip() for part in cleaned.splitlines() if part.strip()]
+        return parts[-1] if parts else raw.strip()
+
+    def _normalize_triage(raw: str) -> str:
+        lowered = raw.lower()
+        if 'urgent' in lowered:
+            return 'urgent'
+        if 'important' in lowered:
+            return 'important'
+        if 'fyi' in lowered:
+            return 'FYI'
+        return 'informational'
+
+    questions = [
+        'What is this document about?',
+        'What action is requested?',
+        'Is there a deadline or date mentioned?',
+        'Is there an amount, phone number, or next step mentioned?',
+    ]
+    source_snippet = excerpt if excerpt else text[:180].strip()
+
+    triage_prompt = (
+        "Classify the document into exactly one label: urgent, important, FYI, informational.\n"
+        "Rules:\n"
+        "- urgent: immediate danger, same-day emergency, urgent medical action.\n"
+        "- important: routine appointment notices, follow-up visits, insurance notices, medication lists, or forms needing action soon.\n"
+        "- FYI: optional informational notices.\n"
+        "- informational: archival or purely informational documents.\n"
+        "For routine follow-up appointment notices, the correct label is important.\n"
+        f"Document:\n{text[:3000]}\n\n"
+        "Return exactly one label."
+    )
+    triage_raw, triage_meta = generate_text_completion(
+        llm=llm,
+        model=model,
+        system_prompt='Return only the label.',
+        user_prompt=triage_prompt,
+        temperature=0.0,
+        max_tokens=512,
+    )
+    triage = _normalize_triage(_final_text(triage_raw))
+
+    summary_prompt = (
+        "Document text:\n"
+        f"{text[:3500]}\n\n"
+        "Write one concise sentence summarizing the document."
+    )
+    summary_raw, summary_meta = generate_text_completion(
+        llm=llm,
+        model=model,
+        system_prompt='Write one concise sentence only.',
+        user_prompt=summary_prompt,
+        temperature=0.0,
+        max_tokens=96,
+    )
+    summary = _final_text(summary_raw)
+
+    safety_raw, safety_meta = generate_text_completion(
+        llm=llm,
+        model=model,
+        system_prompt='Return one short clause only.',
+        user_prompt=(
+            "Based on the document below, state whether more information is needed in one short clause. "
+            "Use phrasing like 'missing info likely' or 'sufficient detail'.\n\n"
+            f"{text[:2200]}"
+        ),
+        temperature=0.0,
+        max_tokens=24,
+    )
+    safety_note = _final_text(safety_raw)
+
+    qa_items: list[dict[str, str]] = []
+    qa_stats: list[dict[str, Any]] = []
+    for question in questions:
+        answer_raw, answer_meta = generate_text_completion(
+            llm=llm,
+            model=model,
+            system_prompt='Answer the question using only the document text.',
+            user_prompt=(
+                f"QUESTION: {question}\n\n"
+                f"DOCUMENT TEXT:\n{text[:3500]}\n\n"
+                "Return one short sentence only."
+            ),
+            temperature=0.0,
+            max_tokens=96,
+        )
+        qa_items.append({'question': question, 'answer': _final_text(answer_raw), 'citation': source_snippet})
+        qa_stats.append(answer_meta['generation_stats'])
+
+    generation_stats = {
+        'triage': triage_meta['generation_stats'],
+        'summary': summary_meta['generation_stats'],
+        'safety': safety_meta['generation_stats'],
+        'qa': qa_stats,
+    }
+    inference_meta = {
+        'model_id': model.model_id,
+        'model_path': str(model.model_path),
+        'model_source': model.source,
+        'backend': model.backend,
+        'generation_stats': generation_stats,
+    }
+    payload = {
+        'triage': triage,
+        'summary': summary,
+        'qa': qa_items,
+        'citations': [{'question': question, 'snippet': source_snippet} for question in questions],
+        'ocr_preview': summary,
+        'ocr_text': text,
+        'safety': {'missing_info_policy': safety_note, 'invented_values': False},
+        'inbox_items': [
+            {
+                'record_id': 'pending',
+                'title': pack.pack_id,
+                'triage': triage,
+                'summary': summary,
+                'file_type': _first_input_kind(pack),
+            },
+        ],
+        'expected_signals': pack.expected_signals,
+        'evidence': keywords,
+        'inference': inference_meta,
+        'model_id': inference_meta['model_id'],
+        'adapter_name': inference_meta['backend'],
+        'generation_stats': generation_stats,
+        'source_excerpt': source_snippet,
+    }
+    search_text = ' '.join([text, summary, triage, ' '.join(keywords)])
+    result = _base_result(pack, store, 'p1', f'P1: {pack.pack_id}', payload['summary'], payload, search_text)
+    result['record_ids'] = [result['record_id']]
+    result['documents'] = [payload]
+    result['triage'] = triage
+    result['summary'] = summary
+    result['qa'] = qa_items
+    result['citations'] = payload['citations']
+    result['ocr_preview'] = payload['ocr_preview']
+    result['ocr_text'] = payload['ocr_text']
+    result['safety'] = payload['safety']
+    result['inbox_items'] = payload['inbox_items']
+
+    LOGGER.info(
+        json.dumps(
+            {
+                'event': 'p1_model_inference',
+                'pack_id': pack.pack_id,
+                'model_id': inference_meta['model_id'],
+                'adapter_name': inference_meta['backend'],
+                'generation_stats': generation_stats,
+                'triage': triage,
+            },
+            ensure_ascii=False,
+        )
+    )
+    return result

app_kit/server.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from pathlib import Path
+import os
+
+from .config import load_app_config
+from .demo_packs import load_demo_pack
+from .logging_utils import setup_logging
+from .model_registry import load_model_registry
+from .storage import SQLiteStore
+
+
+THEME_CSS_PATH = Path(__file__).resolve().parents[1] / "assets" / "theme.css"
+
+
+def build_index_page() -> str:
+    return """
+    <h1>P1 Elder Paperwork Co-Pilot</h1>
+    <p>Select the P1 project and click a load button to seed a bundled demo pack.</p>
+    <ul>
+      <li>P1: Elder Paperwork Co-Pilot</li>
+    </ul>
+    """
+
+
+def create_launcher():
+    import gradio as gr
+
+    root = Path(os.environ.get('APP_ROOT_DIR', Path.cwd())).resolve()
+    config = load_app_config('p1')
+    registry = load_model_registry(config.model_registry_path)
+    logger = setup_logging('app_kit.server')
+    logger.info('app kit server started: %s', list(registry.get('projects', {}).keys()))
+    store = SQLiteStore(config.sqlite_path, config.artifact_dir)
+
+    with gr.Blocks(title='P1 Elder Paperwork Co-Pilot', css_paths=THEME_CSS_PATH) as demo:
+        gr.HTML(build_index_page())
+        project = gr.Dropdown(choices=['p1'], value='p1', label='Project')
+        pack = gr.Textbox(label='Demo pack path', placeholder=str(root / 'data' / 'demo_packs' / 'p1_elder_paperwork'))
+        output = gr.JSON(label='Latest result')
+        status = gr.Textbox(label='Status')
+
+        def load_pack(path: str):
+            demo_pack = load_demo_pack(path)
+            return demo_pack.manifest, f'loaded {demo_pack.pack_id}'
+
+        def show_history(proj: str):
+            return store.history(proj)
+
+        load_button = gr.Button('Load demo pack')
+        history_button = gr.Button('Refresh history')
+        load_button.click(load_pack, inputs=[pack], outputs=[output, status])
+        history_button.click(show_history, inputs=[project], outputs=[output])
+
+    return demo
+
+
+def main() -> int:
+    launcher = create_launcher()
+    launcher.launch(
+        server_name=os.environ.get('GRADIO_SERVER_NAME', '0.0.0.0'),
+        server_port=int(os.environ.get('PORT', '7860')),
+        show_error=True,
+        share=False,
+    )
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

app_kit/sponsor_policy.py

@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+from typing import Any
+import json
+
+try:
+    import yaml
+except Exception:  # pragma: no cover
+    yaml = None
+
+
+DEFAULT_POLICY_RELATIVE_PATH = Path("configs/sponsor_model_policy.yaml")
+DEFAULT_WAIVER_RELATIVE_PATH = Path("configs/sponsor_model_waiver.yaml")
+
+
+@dataclass(frozen=True)
+class SponsorRequirement:
+    scope: str
+    key: str
+    component: str
+    model_id: str
+
+
+@dataclass(frozen=True)
+class SponsorMismatch:
+    scope: str
+    key: str
+    expected_component: str
+    expected_model_id: str
+    actual_component: str | None
+    actual_model_id: str | None
+    problem: str
+
+
+@dataclass(frozen=True)
+class SponsorWaiver:
+    path: Path
+    reason: str
+    date: str
+    approved_by: str
+
+
+@dataclass(frozen=True)
+class SponsorPolicyCheckResult:
+    ok: bool
+    requirements: tuple[SponsorRequirement, ...]
+    mismatches: tuple[SponsorMismatch, ...]
+    waiver: SponsorWaiver | None
+
+
+def _load_data(path: Path) -> Any:
+    text = path.read_text(encoding="utf-8")
+    if path.suffix.lower() == ".json":
+        return json.loads(text)
+    if yaml is not None:
+        return yaml.safe_load(text)
+    return json.loads(text)
+
+
+def load_policy(path: str | Path) -> dict[str, Any]:
+    path = Path(path)
+    data = _load_data(path)
+    if not isinstance(data, dict):
+        raise ValueError(f"sponsor policy must be a mapping, got {type(data)!r}")
+    return data
+
+
+def load_registry(path: str | Path) -> dict[str, Any]:
+    path = Path(path)
+    data = _load_data(path)
+    if not isinstance(data, dict):
+        raise ValueError(f"model registry must be a mapping, got {type(data)!r}")
+    return data
+
+
+def _require_mapping(data: Any, *, label: str) -> dict[str, Any]:
+    if not isinstance(data, dict):
+        raise ValueError(f"{label} must be a mapping, got {type(data)!r}")
+    return data
+
+
+def _require_model_spec(
+    *,
+    spec: Any,
+    label: str,
+    scope: str,
+    key: str,
+    component_default: str,
+) -> SponsorRequirement:
+    spec = _require_mapping(spec, label=label)
+    component = str(spec.get("component", component_default))
+    model_id = spec.get("model_id")
+    if not component:
+        raise ValueError(f"{label}.component must be a non-empty string")
+    if not isinstance(model_id, str) or not model_id.strip():
+        raise ValueError(f"{label}.model_id must be a non-empty string")
+    return SponsorRequirement(scope=scope, key=key, component=component, model_id=model_id)
+
+
+def _iter_requirements(policy: dict[str, Any]) -> tuple[SponsorRequirement, ...]:
+    required = policy.get("required_models", policy)
+    required = _require_mapping(required, label="sponsor policy.required_models")
+    requirements: list[SponsorRequirement] = []
+
+    shared = required.get("shared", {})
+    shared = _require_mapping(shared, label="sponsor policy.required_models.shared")
+    for key, spec in shared.items():
+        requirements.append(
+            _require_model_spec(
+                spec=spec,
+                label=f"sponsor policy.required_models.shared.{key}",
+                scope="shared",
+                key=key,
+                component_default=key,
+            )
+        )
+
+    projects = required.get("projects", {})
+    projects = _require_mapping(projects, label="sponsor policy.required_models.projects")
+    for project_key, spec in projects.items():
+        spec = _require_mapping(spec, label=f"sponsor policy.required_models.projects.{project_key}")
+        if "model_id" in spec:
+            requirements.append(
+                _require_model_spec(
+                    spec=spec,
+                    label=f"sponsor policy.required_models.projects.{project_key}",
+                    scope="projects",
+                    key=project_key,
+                    component_default="",
+                )
+            )
+            continue
+
+        for component_key, component_spec in spec.items():
+            if not isinstance(component_spec, dict):
+                raise ValueError(
+                    f"sponsor policy.required_models.projects.{project_key}.{component_key} must be a mapping"
+                )
+            requirements.append(
+                _require_model_spec(
+                    spec=component_spec,
+                    label=f"sponsor policy.required_models.projects.{project_key}.{component_key}",
+                    scope="projects",
+                    key=project_key,
+                    component_default=component_key,
+                )
+            )
+
+    return tuple(requirements)
+
+
+def _validate_waiver(path: Path, waiver_data: Any) -> SponsorWaiver:
+    data = _require_mapping(waiver_data, label="sponsor waiver")
+    reason = data.get("reason")
+    approved_by = data.get("approved_by")
+    waiver_date = data.get("date")
+    if not isinstance(reason, str) or not reason.strip():
+        raise ValueError("sponsor waiver.reason must be a non-empty string")
+    if not isinstance(approved_by, str) or not approved_by.strip():
+        raise ValueError("sponsor waiver.approved_by must be a non-empty string")
+    if not isinstance(waiver_date, str) or not waiver_date.strip():
+        raise ValueError("sponsor waiver.date must be a non-empty string")
+    try:
+        date.fromisoformat(waiver_date)
+    except ValueError as exc:
+        raise ValueError("sponsor waiver.date must use ISO format YYYY-MM-DD") from exc
+    return SponsorWaiver(path=path, reason=reason.strip(), date=waiver_date.strip(), approved_by=approved_by.strip())
+
+
+def load_waiver(path: str | Path | None) -> SponsorWaiver | None:
+    if path is None:
+        return None
+    path = Path(path)
+    if not path.exists():
+        return None
+    return _validate_waiver(path, _load_data(path))
+
+
+def _registry_entry_for_requirement(registry: dict[str, Any], requirement: SponsorRequirement) -> dict[str, Any] | None:
+    if requirement.scope == "shared":
+        shared = registry.get("shared", {})
+        if not isinstance(shared, dict):
+            raise ValueError("model registry.shared must be a mapping")
+        entry = shared.get(requirement.key)
+        return entry if isinstance(entry, dict) else None
+    if requirement.scope == "projects":
+        projects = registry.get("projects", {})
+        if not isinstance(projects, dict):
+            raise ValueError("model registry.projects must be a mapping")
+        project = projects.get(requirement.key)
+        if not isinstance(project, dict):
+            return None
+        if "model_id" in project or "component" in project:
+            return project
+        entry = project.get(requirement.component)
+        return entry if isinstance(entry, dict) else None
+    raise ValueError(f"unsupported sponsor requirement scope: {requirement.scope!r}")
+
+
+def check_sponsor_policy(
+    model_registry_path: str | Path,
+    policy_path: str | Path,
+    waiver_path: str | Path | None = None,
+) -> SponsorPolicyCheckResult:
+    registry = load_registry(model_registry_path)
+    policy = load_policy(policy_path)
+    requirements = _iter_requirements(policy)
+    waiver = load_waiver(waiver_path)
+
+    mismatches: list[SponsorMismatch] = []
+    for requirement in requirements:
+        entry = _registry_entry_for_requirement(registry, requirement)
+        if entry is None:
+            mismatches.append(
+                SponsorMismatch(
+                    scope=requirement.scope,
+                    key=requirement.key,
+                    expected_component=requirement.component,
+                    expected_model_id=requirement.model_id,
+                    actual_component=None,
+                    actual_model_id=None,
+                    problem="missing registry entry",
+                )
+            )
+            continue
+        actual_component = entry.get("component")
+        actual_model_id = entry.get("model_id")
+        if actual_component != requirement.component or actual_model_id != requirement.model_id:
+            if actual_component != requirement.component and actual_model_id != requirement.model_id:
+                problem = "component and model_id mismatch"
+            elif actual_component != requirement.component:
+                problem = "component mismatch"
+            else:
+                problem = "model_id mismatch"
+            mismatches.append(
+                SponsorMismatch(
+                    scope=requirement.scope,
+                    key=requirement.key,
+                    expected_component=requirement.component,
+                    expected_model_id=requirement.model_id,
+                    actual_component=actual_component if isinstance(actual_component, str) else None,
+                    actual_model_id=actual_model_id if isinstance(actual_model_id, str) else None,
+                    problem=problem,
+                )
+            )
+
+    ok = not mismatches or waiver is not None
+    return SponsorPolicyCheckResult(ok=ok, requirements=requirements, mismatches=tuple(mismatches), waiver=waiver)
+
+
+def format_sponsor_policy_result(result: SponsorPolicyCheckResult) -> tuple[str, str, int]:
+    if result.mismatches and result.waiver is None:
+        lines = ["ERROR: sponsor model mismatch detected:"]
+        for mismatch in result.mismatches:
+            actual_component = mismatch.actual_component or "<missing>"
+            actual_model_id = mismatch.actual_model_id or "<missing>"
+            lines.append(
+                f"- {mismatch.scope}.{mismatch.key}: expected component={mismatch.expected_component!r}, "
+                f"model_id={mismatch.expected_model_id!r}; got component={actual_component!r}, "
+                f"model_id={actual_model_id!r} ({mismatch.problem})"
+            )
+        lines.append("Fix configs/model_registry.yaml or provide configs/sponsor_model_waiver.yaml to justify the exception.")
+        return ("", "\n".join(lines), 1)
+
+    if result.mismatches and result.waiver is not None:
+        warning_lines = [
+            "WARNING: sponsor model mismatch waived.",
+            f"- waiver file: {result.waiver.path}",
+            f"- approved_by: {result.waiver.approved_by}",
+            f"- date: {result.waiver.date}",
+            f"- reason: {result.waiver.reason}",
+        ]
+        stdout = "Sponsor model policy check passed with waiver."
+        return (stdout, "\n".join(warning_lines), 0)
+
+    stdout = f"Sponsor model policy check passed: {len(result.requirements)} required sponsor model(s) aligned."
+    return (stdout, "", 0)

app_kit/storage.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+import shutil
+import uuid
+
+from .embedding import SimpleEmbeddingIndex
+
+
+DEFAULT_DB_PATH = Path('app_data.sqlite3')
+
+
+def init_db(db_path: str | Path = DEFAULT_DB_PATH, artifact_dir: str | Path | None = None) -> None:
+    db_path = Path(db_path)
+    artifact_dir = Path(artifact_dir) if artifact_dir is not None else db_path.parent / 'artifacts'
+    store = SQLiteStore(db_path, artifact_dir)
+    store.close()
+
+
+def reset_db(db_path: str | Path = DEFAULT_DB_PATH, artifact_dir: str | Path | None = None) -> None:
+    db_path = Path(db_path)
+    if db_path.exists():
+        db_path.unlink()
+    init_db(db_path, artifact_dir)
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS artifacts (
+    id TEXT PRIMARY KEY,
+    project TEXT NOT NULL,
+    pack_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    path TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    metadata_json TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS records (
+    id TEXT PRIMARY KEY,
+    project TEXT NOT NULL,
+    pack_id TEXT NOT NULL,
+    title TEXT NOT NULL,
+    primary_text TEXT NOT NULL,
+    json_blob TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS embeddings (
+    record_id TEXT PRIMARY KEY,
+    project TEXT NOT NULL,
+    vector_json TEXT NOT NULL,
+    metadata_json TEXT NOT NULL,
+    created_at TEXT NOT NULL
+);
+"""
+
+
+@dataclass
+class StoredPackResult:
+    record_id: str
+    title: str
+    primary_text: str
+    json_blob: dict[str, Any]
+    status: str
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class SQLiteStore:
+    def __init__(self, db_path: str | Path, artifact_dir: str | Path):
+        self.db_path = Path(db_path)
+        self.artifact_dir = Path(artifact_dir)
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.artifact_dir.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._conn.executescript(SCHEMA)
+        self._conn.commit()
+
+    def close(self) -> None:
+        self._conn.close()
+
+    def store_artifact(self, project: str, pack_id: str, source_path: Path, kind: str, metadata: dict[str, Any] | None = None) -> str:
+        artifact_id = str(uuid.uuid4())
+        dest = self.artifact_dir / f'{artifact_id}{source_path.suffix or ".bin"}'
+        shutil.copy2(source_path, dest)
+        self._conn.execute(
+            'INSERT INTO artifacts VALUES (?, ?, ?, ?, ?, ?, ?)',
+            (artifact_id, project, pack_id, kind, str(dest), utc_now(), json.dumps(metadata or {}, ensure_ascii=False)),
+        )
+        self._conn.commit()
+        return artifact_id
+
+    def store_record(self, project: str, pack_id: str, title: str, primary_text: str, payload: dict[str, Any], status: str = 'stored', record_id: str | None = None) -> str:
+        record_id = record_id or str(uuid.uuid4())
+        self._conn.execute(
+            'INSERT OR REPLACE INTO records VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
+            (record_id, project, pack_id, title, primary_text, json.dumps(payload, ensure_ascii=False), status, utc_now()),
+        )
+        self._conn.commit()
+        return record_id
+
+    def store_embedding(self, record_id: str, project: str, text: str, metadata: dict[str, Any] | None = None) -> None:
+        vec = SimpleEmbeddingIndex()
+        vec.add(record_id, text)
+        vector_json = json.dumps({token: count for token, count in vec.entries[record_id].items()}, ensure_ascii=False)
+        self._conn.execute(
+            'INSERT OR REPLACE INTO embeddings VALUES (?, ?, ?, ?, ?)',
+            (record_id, project, vector_json, json.dumps(metadata or {}, ensure_ascii=False), utc_now()),
+        )
+        self._conn.commit()
+
+    def _embedding_index(self, project: str) -> SimpleEmbeddingIndex:
+        index = SimpleEmbeddingIndex()
+        rows = self._conn.execute('SELECT record_id, vector_json FROM embeddings WHERE project = ?', (project,)).fetchall()
+        for row in rows:
+            index.entries[row['record_id']] = __import__('collections').Counter(json.loads(row['vector_json']))
+        return index
+
+    def search_records(self, project: str, query: str, limit: int = 5) -> list[dict[str, Any]]:
+        index = self._embedding_index(project)
+        scored = index.search(query, limit=limit)
+        if not scored:
+            return []
+        ids = [record_id for record_id, score in scored if score > 0]
+        if not ids:
+            ids = [record_id for record_id, _ in scored]
+        out = []
+        for record_id in ids:
+            row = self._conn.execute('SELECT * FROM records WHERE id = ?', (record_id,)).fetchone()
+            if row:
+                out.append(dict(row))
+        return out[:limit]
+
+    def list_records(self, project: str) -> list[dict[str, Any]]:
+        rows = self._conn.execute('SELECT * FROM records WHERE project = ? ORDER BY created_at DESC', (project,)).fetchall()
+        return [dict(row) for row in rows]
+
+    def get_record(self, record_id: str) -> dict[str, Any] | None:
+        row = self._conn.execute('SELECT * FROM records WHERE id = ?', (record_id,)).fetchone()
+        return dict(row) if row else None
+
+    def inbox(self, project: str) -> list[dict[str, Any]]:
+        return self.list_records(project)
+
+    def history(self, project: str) -> list[dict[str, Any]]:
+        return self.list_records(project)

app_kit/tracing.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+import json
+import uuid
+from dataclasses import asdict, is_dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+_CANONICAL_INPUT_KEYS = (
+    'inputs',
+    'input',
+    'pack',
+    'pack_id',
+    'pack_name',
+    'pack_path',
+    'project',
+    'scenario_id',
+    'scenario_count',
+    'query',
+    'prompt',
+    'transcript',
+    'text',
+)
+_MODEL_HINT_KEYS = (
+    'model_name',
+    'base_model_id',
+    'base_model',
+    'model_id',
+    'adapter_name',
+    'loaded_from',
+    'adapter_path',
+)
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec='seconds')
+
+def _json_safe(value: Any) -> Any:
+    if is_dataclass(value):
+        return _json_safe(asdict(value))
+    if isinstance(value, Path):
+        return str(value)
+    if isinstance(value, dict):
+        return {str(key): _json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(item) for item in value]
+    return value
+
+def _nonempty(value: Any) -> bool:
+    return value not in (None, '', [], {}, ())
+
+def _infer_input_payload(payload: dict[str, Any]) -> Any:
+    existing_inputs = payload.get('inputs')
+    if _nonempty(existing_inputs):
+        return existing_inputs
+    inputs: dict[str, Any] = {}
+    for key in _CANONICAL_INPUT_KEYS:
+        if key in payload and key != 'inputs' and _nonempty(payload[key]):
+            inputs[key] = payload[key]
+    if inputs:
+        return inputs
+    for key in ('project', 'pack_id', 'pack_name', 'pack_path', 'pack'):
+        if key in payload and _nonempty(payload[key]):
+            inputs[key] = payload[key]
+    return inputs
+
+def _infer_model_name(value: Any) -> str | None:
+    if isinstance(value, dict):
+        for key in _MODEL_HINT_KEYS:
+            candidate = value.get(key)
+            if isinstance(candidate, str) and candidate.strip():
+                return candidate.strip()
+        for item in value.values():
+            candidate = _infer_model_name(item)
+            if candidate:
+                return candidate
+    elif isinstance(value, list):
+        for item in value:
+            candidate = _infer_model_name(item)
+            if candidate:
+                return candidate
+    return None
+
+def canonicalize_trace_payload(payload: dict[str, Any]) -> dict[str, Any]:
+    normalized = _json_safe(payload)
+    timestamp = normalized.get('timestamp') or normalized.get('finished_at') or normalized.get('started_at') or utc_now()
+    parsed_outputs = normalized.get('parsed_outputs')
+    if not _nonempty(parsed_outputs):
+        parsed_outputs = normalized.get('result')
+    if not _nonempty(parsed_outputs):
+        parsed_outputs = normalized.get('results')
+    if not _nonempty(parsed_outputs):
+        parsed_outputs = normalized.get('output')
+    if not _nonempty(parsed_outputs):
+        parsed_outputs = {}
+    model_name = normalized.get('model_name')
+    if not _nonempty(model_name):
+        model_name = _infer_model_name(parsed_outputs) or _infer_model_name(normalized)
+    if not _nonempty(model_name):
+        model_name = f"{normalized.get('project') or normalized.get('kind') or 'unknown'}:rule-based"
+    normalized['timestamp'] = str(timestamp)
+    normalized['inputs'] = _infer_input_payload(normalized)
+    normalized['parsed_outputs'] = parsed_outputs
+    normalized['model_name'] = str(model_name)
+    return normalized
+
+def write_trace_artifact(artifact_dir: str | Path, payload: dict[str, Any]) -> Path:
+    artifact_dir = Path(artifact_dir)
+    trace_dir = artifact_dir / 'traces'
+    trace_dir.mkdir(parents=True, exist_ok=True)
+    run_id = str(payload.get('run_id') or uuid.uuid4().hex)
+    kind = str(payload.get('kind', 'trace')).strip().replace('/', '_').replace(' ', '_') or 'trace'
+    trace_path = trace_dir / f'{kind}-{run_id}.json'
+    normalized = canonicalize_trace_payload(payload)
+    normalized['run_id'] = run_id
+    normalized['trace_path'] = str(trace_path)
+    trace_path.write_text(json.dumps(normalized, indent=2, ensure_ascii=False, sort_keys=True, default=str), encoding='utf-8')
+    return trace_path

assets/theme.css

@@ -0,0 +1,235 @@
+/* P1 Elder Care Document Assistant — calming, accessible dark UI */
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=Outfit:wght@500;600;700&display=swap');
+
+:root {
+  color-scheme: dark;
+  --p1-bg-deep: #0c1220;
+  --p1-bg-card: rgba(15, 25, 50, 0.65);
+  --p1-bg-surface: rgba(30, 45, 80, 0.35);
+  --p1-text: #f8fafc;
+  --p1-text-muted: #94a3c8;
+  --p1-accent: #fbbf24;
+  --p1-accent-hover: #f59e0b;
+  --p1-accent-glow: rgba(251, 191, 36, 0.15);
+  --p1-success: #34d399;
+  --p1-warning: #fbbf24;
+  --p1-danger: #f87171;
+  --p1-info: #60a5fa;
+  --p1-border: rgba(96, 165, 250, 0.18);
+  --p1-radius: 16px;
+  --p1-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+}
+
+/* Base container */
+.gradio-container {
+  background:
+    radial-gradient(ellipse at top left, rgba(59, 130, 246, 0.08) 0%, transparent 50%),
+    radial-gradient(ellipse at bottom right, rgba(251, 191, 36, 0.05) 0%, transparent 50%),
+    linear-gradient(180deg, #0f172a 0%, #0c1220 40%, #020617 100%);
+  color: var(--p1-text);
+  font-family: 'Inter', system-ui, -apple-system, 'Segoe UI', sans-serif;
+  font-size: 16px;
+  line-height: 1.6;
+  min-height: 100vh;
+}
+
+/* Typography */
+.gradio-container .prose,
+.gradio-container p,
+.gradio-container span,
+.gradio-container label {
+  color: var(--p1-text);
+}
+
+.gradio-container h1 {
+  font-family: 'Outfit', system-ui, sans-serif;
+  color: var(--p1-accent);
+  font-size: 2rem;
+  font-weight: 700;
+  letter-spacing: -0.01em;
+  text-shadow: 0 0 40px var(--p1-accent-glow);
+}
+
+.gradio-container h2,
+.gradio-container h3 {
+  font-family: 'Outfit', system-ui, sans-serif;
+  color: var(--p1-text);
+  font-weight: 600;
+  letter-spacing: -0.005em;
+}
+
+.gradio-container h4 {
+  color: var(--p1-text-muted);
+}
+
+/* Input fields */
+.gradio-container input,
+.gradio-container textarea,
+.gradio-container select {
+  background: var(--p1-bg-card);
+  color: var(--p1-text);
+  border: 1px solid var(--p1-border);
+  border-radius: var(--p1-radius);
+  backdrop-filter: blur(8px);
+  transition: border-color 0.2s ease, box-shadow 0.2s ease;
+}
+
+.gradio-container input:focus,
+.gradio-container textarea:focus {
+  border-color: var(--p1-accent);
+  box-shadow: 0 0 0 3px var(--p1-accent-glow);
+  outline: none;
+}
+
+/* Buttons */
+.gradio-container button {
+  border-radius: 999px;
+  font-weight: 600;
+  font-family: 'Inter', system-ui, sans-serif;
+  transition: all 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+  letter-spacing: 0.01em;
+}
+
+.gradio-container button.primary,
+.gradio-container button.lg.primary {
+  background: linear-gradient(135deg, var(--p1-accent) 0%, #f97316 100%);
+  color: #111827;
+  font-weight: 700;
+  box-shadow: 0 4px 16px rgba(251, 191, 36, 0.25);
+  border: none;
+}
+
+.gradio-container button.primary:hover {
+  transform: translateY(-1px);
+  box-shadow: 0 6px 24px rgba(251, 191, 36, 0.35);
+}
+
+.gradio-container button.secondary {
+  background: var(--p1-bg-card);
+  color: var(--p1-text);
+  border: 1px solid var(--p1-border);
+  backdrop-filter: blur(8px);
+}
+
+.gradio-container button.secondary:hover {
+  border-color: var(--p1-accent);
+  background: var(--p1-bg-surface);
+}
+
+/* Upload area */
+.gradio-container .upload-area {
+  border: 2px dashed rgba(96, 165, 250, 0.3);
+  border-radius: 20px;
+  background: var(--p1-bg-card);
+  backdrop-filter: blur(12px);
+  transition: border-color 0.3s ease, background 0.3s ease;
+}
+
+.gradio-container .upload-area:hover {
+  border-color: var(--p1-accent);
+  background: rgba(251, 191, 36, 0.05);
+}
+
+/* Result cards */
+.gradio-container .result-card,
+.gradio-container .history-card,
+.gradio-container .status-box {
+  background: var(--p1-bg-card);
+  border: 1px solid var(--p1-border);
+  border-radius: var(--p1-radius);
+  padding: 1.25rem;
+  backdrop-filter: blur(12px);
+  box-shadow: var(--p1-shadow);
+  color: var(--p1-text) !important;
+}
+
+.gradio-container .result-card p,
+.gradio-container .history-card p,
+.gradio-container .status-box p,
+.gradio-container .result-card span,
+.gradio-container .history-card span {
+  color: var(--p1-text) !important;
+}
+
+
+.gradio-container .result-card h3 {
+  margin-top: 0;
+}
+
+/* Search box */
+.gradio-container .search-box input {
+  padding-left: 1rem;
+}
+
+/* Accordion */
+.gradio-container .accordion {
+  background: var(--p1-bg-surface);
+  border: 1px solid var(--p1-border);
+  border-radius: var(--p1-radius);
+}
+
+/* Markdown formatting within results */
+.gradio-container .markdown-text blockquote {
+  border-left: 3px solid var(--p1-accent);
+  padding-left: 1rem;
+  margin-left: 0;
+  color: var(--p1-text-muted);
+  font-style: italic;
+}
+
+.gradio-container .markdown-text code {
+  background: rgba(96, 165, 250, 0.12);
+  color: var(--p1-info);
+  padding: 0.15rem 0.4rem;
+  border-radius: 6px;
+  font-size: 0.85em;
+}
+
+.gradio-container .markdown-text hr {
+  border-color: var(--p1-border);
+  margin: 1rem 0;
+}
+
+/* JSON panel (kept for dev accordion) */
+.gradio-container .json-holder {
+  background: var(--p1-bg-card);
+  border: 1px solid var(--p1-border);
+  border-radius: var(--p1-radius);
+}
+
+/* Scrollbar */
+.gradio-container ::-webkit-scrollbar {
+  width: 6px;
+}
+
+.gradio-container ::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.gradio-container ::-webkit-scrollbar-thumb {
+  background: rgba(96, 165, 250, 0.25);
+  border-radius: 4px;
+}
+
+/* Footer */
+.gradio-container footer {
+  opacity: 0.5;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+  .gradio-container h1 {
+    font-size: 1.5rem;
+  }
+}
+
+/* Micro-animations */
+@keyframes fadeIn {
+  from { opacity: 0; transform: translateY(8px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+.gradio-container .result-card,
+.gradio-container .history-card {
+  animation: fadeIn 0.4s ease-out;
+}

configs/model_registry.yaml

@@ -0,0 +1,59 @@
+shared:
+  embedder:
+    component: embedder
+    model_id: sentence-transformers/all-MiniLM-L6-v2
+    license: Apache-2.0
+    usage_notes: Offline embedding baseline for search and retrieval helpers.
+    runtime: heuristic+hf
+    backend: sentence-transformers
+    local_fallback: builtin-text-similarity
+  summary_llm:
+    component: summary_llm
+    model_id: openbmb/MiniCPM-5-1B
+    license: MiniCPM-custom
+    usage_notes: Plain-language summaries and triage narration for elder paperwork.
+    runtime: heuristic+hf
+    backend: transformers
+    local_fallback: deterministic-template
+projects:
+  p1:
+    ocr_vlm:
+      component: ocr_vlm
+      model_id: openbmb/MiniCPM-V-4_6
+      params: "~1.3B"
+      sponsor: MiniCPM
+      license: MiniCPM-custom
+      usage_notes: OCR and layout understanding for scanned elder paperwork.
+      runtime: heuristic+hf
+      backend: transformers
+      local_fallback: deterministic-ocr
+    triage_llm:
+      component: triage_llm
+      model_id: openbmb/MiniCPM-5-1B
+      params: "1B"
+      sponsor: MiniCPM
+      license: MiniCPM-custom
+      usage_notes: Triage labels and plain-language summaries for elder paperwork packets.
+      runtime: heuristic+hf
+      backend: transformers
+      local_fallback: deterministic-template
+    table_parser:
+      component: table_parser
+      model_id: nvidia/NVIDIA-Nemotron-Parse-v1.1
+      params: "<1B"
+      sponsor: NeMoTRON
+      license: NVIDIA
+      usage_notes: Structured extraction of tables and form fields from bills and notices.
+      runtime: heuristic+hf
+      backend: transformers
+      local_fallback: deterministic-table-parser
+    asr:
+      component: asr
+      model_id: CohereLabs/cohere-transcribe-03-2026
+      params: "2B"
+      sponsor: CoExpression
+      license: proprietary
+      usage_notes: Voice-note transcription for caregiver follow-ups.
+      runtime: heuristic+hf
+      backend: transformers
+      local_fallback: offline-transcribe

configs/sponsor_model_policy.yaml

@@ -0,0 +1,17 @@
+version: 1
+purpose: sponsor-model alignment gate for the ALL4 P1 elder paperwork repo
+required_models:
+  projects:
+    p1:
+      ocr_vlm:
+        component: ocr_vlm
+        model_id: openbmb/MiniCPM-V-4_6
+      triage_llm:
+        component: triage_llm
+        model_id: openbmb/MiniCPM-5-1B
+      table_parser:
+        component: table_parser
+        model_id: nvidia/NVIDIA-Nemotron-Parse-v1.1
+      asr:
+        component: asr
+        model_id: CohereLabs/cohere-transcribe-03-2026

data/README.md

@@ -0,0 +1,9 @@
+# Data
+
+Bundled demo packs:
+- `p1_elder_paperwork/` — synthetic elder-paperwork notices, OCR-lite samples, and test packs for the P1 app.
+
+All bundled P1 demo assets are synthetic or generated for this repository and are intended to be redistributable in a public Hugging Face Space.
+
+License for bundled demo assets: CC0-1.0.
+No PII/PHI is included.

data/demo_packs/p1_elder_paperwork/sample_appointment_notice/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_appointment_notice

data/demo_packs/p1_elder_paperwork/sample_appointment_notice/inputs/note.txt

@@ -0,0 +1 @@
+Appointment notice for a routine follow-up visit next Tuesday. Please bring your medication list and insurance card.

data/demo_packs/p1_elder_paperwork/sample_appointment_notice/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_appointment_notice",
+  "description": "p1_elder_paperwork demo pack sample_appointment_notice",
+  "inputs": [
+    {
+      "path": "inputs/note.txt",
+      "kind": "txt",
+      "label": "sample_appointment_notice"
+    }
+  ],
+  "expected_signals": {
+    "triage": "important"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "Appointment notice for a routine follow-up visit next Tuesday. Please bring your medication list and insurance card."
+}

data/demo_packs/p1_elder_paperwork/sample_benefits_renewal_png/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_benefits_renewal_png

data/demo_packs/p1_elder_paperwork/sample_benefits_renewal_png/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_benefits_renewal_png",
+  "description": "p1_elder_paperwork demo pack sample_benefits_renewal_png",
+  "inputs": [
+    {
+      "path": "inputs/benefits.png",
+      "kind": "png",
+      "label": "sample_benefits_renewal_png"
+    }
+  ],
+  "expected_signals": {
+    "triage": "important"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "Benefits renewal reminder. Return the verification form within 10 days to keep coverage active."
+}

data/demo_packs/p1_elder_paperwork/sample_clinic_reminder_txt/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_clinic_reminder_txt

data/demo_packs/p1_elder_paperwork/sample_clinic_reminder_txt/inputs/reminder.txt

@@ -0,0 +1 @@
+Clinic reminder: annual wellness visit scheduled for next month. This is a routine informational notice.

data/demo_packs/p1_elder_paperwork/sample_clinic_reminder_txt/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_clinic_reminder_txt",
+  "description": "p1_elder_paperwork demo pack sample_clinic_reminder_txt",
+  "inputs": [
+    {
+      "path": "inputs/reminder.txt",
+      "kind": "txt",
+      "label": "sample_clinic_reminder_txt"
+    }
+  ],
+  "expected_signals": {
+    "triage": "important"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "Clinic reminder: annual wellness visit scheduled for next month. This is a routine informational notice."
+}

data/demo_packs/p1_elder_paperwork/sample_final_notice_pdf/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_final_notice_pdf

data/demo_packs/p1_elder_paperwork/sample_final_notice_pdf/inputs/notice.pdf

@@ -0,0 +1,32 @@
+%PDF-1.4
+1 0 obj
+<< /Type /Catalog /Pages 2 0 R >>
+endobj
+2 0 obj
+<< /Type /Pages /Kids [3 0 R] /Count 1 >>
+endobj
+3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>
+endobj
+4 0 obj
+<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+endobj
+5 0 obj
+<< /Length 135 >>
+stream
+BT /F1 12 Tf 72 720 Td (Final notice: your account is past due. Please pay the remaining balance by 06/18/2026 or call 555-0142.) Tj ET
+endstream
+endobj
+xref
+0 6
+0000000000 65535 f 
+0000000009 00000 n 
+0000000058 00000 n 
+0000000115 00000 n 
+0000000241 00000 n 
+0000000311 00000 n 
+trailer
+<< /Size 6 /Root 1 0 R >>
+startxref
+497
+%%EOF

data/demo_packs/p1_elder_paperwork/sample_final_notice_pdf/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_final_notice_pdf",
+  "description": "p1_elder_paperwork demo pack sample_final_notice_pdf",
+  "inputs": [
+    {
+      "path": "inputs/notice.pdf",
+      "kind": "pdf",
+      "label": "sample_final_notice_pdf"
+    }
+  ],
+  "expected_signals": {
+    "triage": "urgent"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "Final notice: your account is past due. Please pay the remaining balance by 06/18/2026 or call 555-0142."
+}

data/demo_packs/p1_elder_paperwork/sample_insurance_letter_png/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_insurance_letter_png

data/demo_packs/p1_elder_paperwork/sample_insurance_letter_png/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_insurance_letter_png",
+  "description": "p1_elder_paperwork demo pack sample_insurance_letter_png",
+  "inputs": [
+    {
+      "path": "inputs/insurance_letter.png",
+      "kind": "png",
+      "label": "sample_insurance_letter_png"
+    }
+  ],
+  "expected_signals": {
+    "triage": "important"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "Insurance letter with coverage update and appeal rights. Contact member services if the mailing address is wrong."
+}

data/demo_packs/p1_elder_paperwork/sample_lab_reminder_txt/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_lab_reminder_txt

data/demo_packs/p1_elder_paperwork/sample_lab_reminder_txt/inputs/lab_reminder.txt

@@ -0,0 +1 @@
+Lab reminder: routine blood work is due sometime this month. No action is needed today.

data/demo_packs/p1_elder_paperwork/sample_lab_reminder_txt/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_lab_reminder_txt",
+  "description": "p1_elder_paperwork demo pack sample_lab_reminder_txt",
+  "inputs": [
+    {
+      "path": "inputs/lab_reminder.txt",
+      "kind": "txt",
+      "label": "sample_lab_reminder_txt"
+    }
+  ],
+  "expected_signals": {
+    "triage": "important"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "Lab reminder: routine blood work is due sometime this month. No action is needed today."
+}

data/demo_packs/p1_elder_paperwork/sample_medication_change_pdf/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_medication_change_pdf

data/demo_packs/p1_elder_paperwork/sample_medication_change_pdf/inputs/medication_change.pdf

@@ -0,0 +1,32 @@
+%PDF-1.4
+1 0 obj
+<< /Type /Catalog /Pages 2 0 R >>
+endobj
+2 0 obj
+<< /Type /Pages /Kids [3 0 R] /Count 1 >>
+endobj
+3 0 obj
+<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 4 0 R >> >> /Contents 5 0 R >>
+endobj
+4 0 obj
+<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>
+endobj
+5 0 obj
+<< /Length 152 >>
+stream
+BT /F1 12 Tf 72 720 Td (Medication change update from clinic. Continue current dose and review the attached instructions at the next appointment.) Tj ET
+endstream
+endobj
+xref
+0 6
+0000000000 65535 f 
+0000000009 00000 n 
+0000000058 00000 n 
+0000000115 00000 n 
+0000000241 00000 n 
+0000000311 00000 n 
+trailer
+<< /Size 6 /Root 1 0 R >>
+startxref
+514
+%%EOF

data/demo_packs/p1_elder_paperwork/sample_medication_change_pdf/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_medication_change_pdf",
+  "description": "p1_elder_paperwork demo pack sample_medication_change_pdf",
+  "inputs": [
+    {
+      "path": "inputs/medication_change.pdf",
+      "kind": "pdf",
+      "label": "sample_medication_change_pdf"
+    }
+  ],
+  "expected_signals": {
+    "triage": "important"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "Medication change update from clinic. Continue current dose and review the attached instructions at the next appointment."
+}

data/demo_packs/p1_elder_paperwork/sample_urgent_notice/README.md

@@ -0,0 +1 @@
+p1_elder_paperwork pack: sample_urgent_notice

data/demo_packs/p1_elder_paperwork/sample_urgent_notice/inputs/note.txt

@@ -0,0 +1 @@
+URGENT billing notice about a past due balance and follow-up deadline. Call the office by Friday.

data/demo_packs/p1_elder_paperwork/sample_urgent_notice/manifest.json

@@ -0,0 +1,18 @@
+{
+  "project": "p1",
+  "pack_id": "p1_elder_paperwork.sample_urgent_notice",
+  "description": "p1_elder_paperwork demo pack sample_urgent_notice",
+  "inputs": [
+    {
+      "path": "inputs/note.txt",
+      "kind": "txt",
+      "label": "sample_urgent_notice"
+    }
+  ],
+  "expected_signals": {
+    "triage": "urgent"
+  },
+  "license": "CC0-1.0",
+  "source": "synthetic",
+  "primary_text": "URGENT billing notice about a past due balance and follow-up deadline. Call the office by Friday."
+}