Sync submission-ready runtime and docs

Makefile

@@ -4,7 +4,7 @@ HOST ?= 127.0.0.1
 PORT ?= 7860
 FIGMENT_SMOKE_TIMEOUT_SECONDS ?= 8
 
-.PHONY: install test run run-hosted-demo build-fts smoke-model-route smoke-local-model-route
+.PHONY: install test run run-hosted-demo build-fts audit-claims evidence-gates smoke-model-route smoke-local-model-route local-4b-evidence local-asr-evidence
 
 install:
 	$(PIP) install --upgrade pip
@@ -27,6 +27,12 @@ build-fts:
 		echo "scripts/build_fts.py not available yet; skipping FTS build."; \
 	fi
 
+audit-claims:
+	$(PYTHON) scripts/audit_submission_claims.py
+
+evidence-gates:
+	$(PYTHON) scripts/evidence_gate_status.py --markdown; status=$$?; test $$status -eq 0 -o $$status -eq 2
+
 smoke-model-route:
 	PYTHON_DOTENV_DISABLED=true FIGMENT_MODE=canned MODEL_STACK=omni_native MODEL_BACKEND=canned AUDIO_BACKEND=none \
 	FIGMENT_SMOKE_ALLOW_NETWORK=false FIGMENT_SMOKE_TIMEOUT_SECONDS=$(FIGMENT_SMOKE_TIMEOUT_SECONDS) \
@@ -35,3 +41,9 @@ smoke-model-route:
 smoke-local-model-route:
 	FIGMENT_MODE=local MODEL_BACKEND=llama_cpp AUDIO_BACKEND=none FIGMENT_SMOKE_ALLOW_NETWORK=true FIGMENT_SMOKE_TIMEOUT_SECONDS=$(FIGMENT_SMOKE_TIMEOUT_SECONDS) \
 	$(PYTHON) scripts/smoke_model_route.py
+
+local-4b-evidence:
+	PYTHON_DOTENV_DISABLED=true $(PYTHON) scripts/run_local_4b_evidence.py --base-url "$${LLAMA_BASE_URL:-http://127.0.0.1:8001/v1}"
+
+local-asr-evidence:
+	PYTHON_DOTENV_DISABLED=true $(PYTHON) scripts/run_local_asr_evidence.py

README.md

@@ -12,87 +12,133 @@ python_version: 3.11
 
 # Figment
 
-**Protocol support for low-connectivity field clinics and disaster response.**
+**Protocol navigation for trained responders in low-connectivity clinics and disaster response.**
 
-Figment uses deterministic rules for danger signs and an AI protocol navigator for messy field notes, missing-observation planning, card-cited responder checklists, and SBAR handoffs. The frozen primary model path is NVIDIA Nemotron 3 Nano Omni: hosted Omni powers live-model demos when configured, and self-hosted Omni can technically support an Off the Grid run if it is served on adequate local hardware with no runtime cloud APIs. The current local/off-grid gap is hardware and recorded evidence, not an architecture impossibility; the smaller proof path targets Nemotron 3 Nano 4B for text navigation plus Parakeet RNNT ASR for dictated intake after verification. (The app scaffold is runnable and still under active development — see **Status** below.)
+Figment turns messy field intake into a card-cited protocol workflow: confirm the facts, run deterministic danger-sign rules, retrieve local protocol cards, ask a small model for bounded navigation fields, validate or repair the output, and show a trace of what happened.
 
-> ⚠️ **Figment is not a medical device.** It does not diagnose, prescribe, or replace a clinician. It is a prototype for protocol navigation, escalation support, and documentation in low-connectivity environments, for use by trained responders. See [Safety & non-goals](#safety--non-goals).
+> **Safety boundary:** Figment is a prototype, not a medical device. It does not diagnose, prescribe, dose medication, autonomously triage, or replace a trained responder, supervisor, clinician, or local protocol.
 
-- **Status:** In active development for the [Build Small Hackathon](docs/build-small-hackathon-org-card.md) (build window **June 5-15, 2026**). The Gradio scaffold, deterministic rules, hosted NVIDIA Omni client, local OpenAI-compatible client, canned fallback, traces, and tests run locally; the hosted NVIDIA API smoke test is green. The public Hugging Face Space now boots with app files present at commit `5dcfc5c830de7331eca9020b17e1c571a8619654`; a no-secret public workflow smoke loaded a demo case, confirmed typed intake, fired deterministic pediatric-dehydration escalation, retrieved protocol cards, and produced an honestly labeled `canned_backend` trace with `validation_status=passed`, `raw_audio_stored=false`, and zero model-retained fields. The 50-case hosted Omni eval has run: baseline whole-output model competence was **28/50**, and the load-bearing follow-up reached **31/50** with **480/650** model-retained fields, **170/650** deterministic patches, **8/50** full fallback, and **50/50** final validation. Local 4B runtime evidence, Parakeet ASR evidence, demo video, social post, and user-test notes are still proof-needed items tracked in the [adversarial review action items](docs/adversarial-review-action-items.md), [hosted eval results](docs/hosted_omni_eval_results.md), [parameter/evidence ledger](docs/model_parameter_evidence_ledger.md), and [submission checklist](docs/submission_checklist.md).
-- **Track target:** Backyard AI (solve a real problem for a specific, real person you know). Final evidence still needs a real trained responder using synthetic or de-identified scenarios; see [user test notes](docs/user_test_notes.md).
-- **Built for:** a real disaster-response volunteer trained in disaster-response first aid and local protocol use; name withheld for privacy.
-- **Model:** NVIDIA **Nemotron 3 Nano Omni 30B-A3B Reasoning** as the v1 default. The model-card body reports 31B total parameters; the workback plan and [parameter/evidence ledger](docs/model_parameter_evidence_ledger.md) track the HF-sidebar count ambiguity, local 4B + Parakeet story, adapter count status, and organizer-confirmation status.
+## Current Snapshot
 
----
+| Surface | Current evidence | What it means | Boundary |
+| --- | --- | --- | --- |
+| Public Space | [build-small-hackathon/figment](https://huggingface.co/spaces/build-small-hackathon/figment) is `RUNNING` and served HTTP 200 when checked on 2026-06-14 at Space commit `ea4d971be2b8d4e1841648e5a9adc5142d16a299`. | The Gradio app is deployable and reachable. | The public no-secret route may use the labeled canned fallback; that is deployment proof, not live hosted-model proof. |
+| Hosted Omni eval | `31/50` whole-output competence, `8/50` full fallback, `480/650` model-retained fields, `170/650` deterministic patches, and `50/50` final validation. | Hosted Omni can carry bounded fields, and the app can keep outputs inside the safety contract. | `50/50` final validation is app safety after validation, repair, and fallback. It is not pure model performance. |
+| 4B LoRA system eval | v14p repair-union on the corrected 150-case field-workflow holdout: `150/150` competence, `150/150` expected labels, `150/150` final validation, `0` deterministic patches, `0` fallback. Raw first-pass success is `146/150`; `4/150` cases close through focused model repair. | The strongest documented small-model result is model-owned output plus model repair on a synthetic/de-identified holdout. | This is not clinical validation, target-user validation, local ASR proof, or proof that raw first-pass output solved every case. |
+| Public artifacts | [model archive](https://huggingface.co/build-small-hackathon/figment-finetuned-model-archive) and [eval/training dataset](https://huggingface.co/datasets/build-small-hackathon/figment-eval-traces). | Versioned BF16/GGUF model artifacts, synthetic corpora, eval traces, and summaries are inspectable outside this checkout. | Generated `traces/`, `data/finetune/`, weights, and checkpoint folders are intentionally not part of a clean clone. |
 
-## Why Figment
+Final submission claims are evidence-gated. Before changing public copy, run:
 
-> What happens when the clinic loses internet?
+```bash
+make audit-claims PYTHON=.venv/bin/python
+make evidence-gates PYTHON=.venv/bin/python
+```
 
-Rural clinics, mobile units, and disaster sites lose connectivity exactly when decisions get hardest. Cloud medical assistants stop working; paper protocol binders don't talk back. Figment is built toward an **offline** mode: with a verified local model route, it can read the same protocol cards a responder would, apply hard-coded danger-sign rules, and turn a messy field note into a structured handoff on the machine in front of you. Until a no-cloud run is recorded, hosted mode and off-grid mode are labeled separately.
+## Why Figment Exists
 
-The design goal is restraint. Figment is **a field protocol binder that can talk, cite itself, and knows when to shut up** — not an "AI doctor."
+When a rural clinic, mobile unit, shelter, or disaster site loses connectivity, the work does not become simpler. Protocol binders still matter, but they do not ask follow-up questions, organize missing observations, or draft a clean handoff.
 
----
+Figment is built as a restrained protocol binder that can talk back. It does not try to be an AI clinician. Its job is narrower:
 
-## What it does
+- preserve deterministic red-flag floors;
+- cite the protocol cards it used;
+- ask for missing observations;
+- produce a responder checklist;
+- draft an SBAR-style handoff;
+- expose whether each field came from raw model output, model repair, or deterministic fallback.
 
-Figment is a [Gradio Server](https://www.gradio.app/guides/server-mode) app with five frozen workflow views:
+That separation is the core project claim: useful small-model systems get safer and easier to improve when the model's job is narrow enough to inspect.
 
-1. **Intake** — structured capture of setting, patient age, pregnancy status, chief concern, symptoms, vitals, allergies, medications, available supplies, and a free-text responder note. Optional audio intake drafts fields only; typed/edited values must be confirmed before rules or navigation run.
-2. **Risk Check** — deterministic red-flag rules fire **before** the LLM and set the minimum urgency floor (e.g. altered mental status, severe respiratory distress, chest pain, stroke signs, pregnancy bleeding, pediatric lethargy, severe dehydration signs, fever escalation criteria, wound infection escalation criteria).
-3. **Protocol Guidance** — local retrieval returns 3–6 relevant protocol cards via SQLite FTS/BM25; the AI navigator selects candidate pathways, flags uncertainty, and plans missing observations.
-4. **Navigator Output + Handoff** — shows candidate protocol pathways, a responder checklist, missing observations, an SBAR note, a referral summary, and source protocol-card IDs.
-5. **Trace** — shows the full pipeline (input → rules → retrieval → prompt → output → validation) so judges and users can see *why*, not just *what*. This is the "show, don't tell" engine.
+## User Workflow
 
----
+Figment's Gradio Server app is organized around the field workflow:
+
+1. **Intake** captures setting, age, pregnancy status, chief concern, symptoms, vitals, allergies, medications, available supplies, and a free-text responder note. Audio intake is only a draft layer; typed or edited facts must be confirmed before rules or navigation run.
+2. **Risk Check** runs deterministic red-flag rules before model navigation and sets the minimum urgency floor.
+3. **Protocol Guidance** retrieves 3-6 local protocol cards through SQLite FTS/BM25, with JSON fallback search.
+4. **Navigator Output + Handoff** returns candidate pathways, uncertainty notes, missing observations, responder checklist, source cards, plain-language script, and SBAR handoff.
+5. **Trace** shows input, rules, retrieval, prompt context, raw output, repair, fallback, validation, route labels, field provenance, and trace hashes.
 
-## How it works
+Three included demo scenarios cover pediatric dehydration, wound infection after disaster injury, and pregnancy danger signs. The demo audio clips are synthetic and are not real patient audio.
+
+## Architecture
 
 ```text
-Gradio Server custom frontend + Gradio API endpoints
-  → structured intake schema
-  → rules.py        (deterministic red-flag engine)
-  → retrieval.py    (SQLite FTS protocol search)
-  → prompt_builder.py (constrained navigator prompt; cards + rules injected)
-  → navigator.py      (AI protocol navigator)
-  → model_client.py   (hosted/self-hosted Omni, local 4B OpenAI-compatible server, or canned fallback)
-  → validators.py   (output validator: JSON, citations, safety checks)
-  → sbar.py         (referral note renderer)
-  → trace.py        (trace export)
+app.py
+  -> confirmed structured intake
+  -> figment/rules.py              deterministic danger-sign rules
+  -> figment/retrieval.py          local protocol-card retrieval
+  -> figment/prompt_builder.py     bounded navigator prompt
+  -> figment/model_client.py       hosted Omni, local OpenAI-compatible, or canned route
+  -> figment/navigator.py          raw output, scaffold, repair, fallback orchestration
+  -> figment/validators.py         schema, citations, urgency floor, safety checks
+  -> figment/field_provenance.py   model_raw / model_repaired / deterministic_fallback labels
+  -> figment/eval_metrics.py       app-safety and model-contribution metrics
+  -> figment/trace.py              auditable route and trace export
 ```
 
-Two principles make this safe rather than chatty:
+The safety pattern is deliberate:
 
-- **Rules before the model.** Danger-sign detection is deterministic code, not a model guess, so a red flag can't be "reasoned away."
-- **The cards are the source of truth; the model is a behavior harness.** The base hosted/local model is prompted and validated to stay inside retrieved cards, cite card IDs, ask for missing observations, preserve deterministic red-flag floors, build checklists, and refuse out-of-scope requests — not to memorize medical facts. Fine-tuning is deferred unless the runtime demo is already safe and reliable.
+- **Rules before model:** danger signs set an urgency floor the model cannot lower.
+- **Cards as source of truth:** the model must stay inside retrieved protocol cards and cite card IDs.
+- **Human confirmation:** audio-derived fields are provisional until the responder confirms them.
+- **Scoped repair:** when an output fails validation, focused repair targets a bounded failure class rather than asking the model to improvise a new answer.
+- **Visible fallback:** deterministic patches and full fallback are counted separately from model competence.
 
----
+## Models
 
-## The model & the ≤32B constraint
+Figment supports three runtime routes:
 
-The Build Small Hackathon caps models at **32B total parameters**. Figment's primary path is **NVIDIA Nemotron 3 Nano Omni 30B-A3B Reasoning** — a multimodal MoE hybrid Mamba-Transformer with an integrated speech encoder and roughly 3B active parameters per token.
+| Route | Backend | Use |
+| --- | --- | --- |
+| Canned fallback | `MODEL_BACKEND=canned` | No-secret app smoke, UI development, honest fallback traces. |
+| Hosted Omni | `MODEL_BACKEND=hosted_omni` with `NVIDIA_API_KEY` | Live hosted demo and hosted eval path using `nvidia/nemotron-3-nano-omni-30b-a3b-reasoning`. |
+| Local OpenAI-compatible | `MODEL_BACKEND=llama_cpp` with `LLAMA_BASE_URL` | Local text-navigation route for the 4B BF16/GGUF artifacts and local evidence bundles. |
 
-> **Compliance note:** NVIDIA's model-card body reports **31B total parameters**, which fits the 32B cap. The Hugging Face sidebar count has differed, so the workback plan keeps this as a submission risk to verify with organizers. The ~3B *active* figure is **not** the compliance number — the limit is on *total* parameters.
+The Build Small constraint is <=32B total parameters. The hosted Omni path is tracked with a parameter-count caveat: the NVIDIA model-card body reports 31B total parameters, while sidebar counts have differed. The 4B BF16 base model, `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16`, is the local text-navigation training target.
 
-The live parameter and proof status is tracked in the [model parameter/evidence ledger](docs/model_parameter_evidence_ledger.md). It separates hosted Omni evidence from the unproven local 4B + Parakeet path, and it keeps adapter counts and organizer confirmation explicit before any badge or compliance claim is upgraded.
+Parakeet ASR remains a gated local-audio path. Artifact presence alone is not enough; local ASR needs provider-output evidence before any local-audio claim is upgraded.
 
-Omni can satisfy an off-grid claim if it is self-hosted on sufficient local hardware and the demo uses no runtime cloud APIs. This repo has not yet recorded that proof. The nearer local/off-grid proof path targets a smaller split stack after verification:
+## Evaluation
 
-| Artifact | Use |
-| -------- | --- |
-| `nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16` | primary hosted/self-hosted Omni model ID |
-| `nvidia/nemotron-3-nano-omni-30b-a3b-reasoning` | NVIDIA API Catalog / NIM chat-completions model ID |
-| `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16` | local text-navigation and first fine-tuning target |
-| `nvidia/parakeet-rnnt-1.1b` | local/offline ASR target, enabled only after the local ASR gate passes |
+Figment reports app safety and model contribution separately.
 
-Reference dev/demo machine: an M4 Pro MacBook Pro with 48 GB RAM. Hosted Omni is the intended public Space story; local audio is Parakeet-only after verification, and the safe local proof may use typed intake or a canned transcript if ASR is not stable. The full 4B BF16 artifact and Parakeet `.nemo` artifact are present locally, but the local 50-case text eval and local ASR provider proof still need to be run before any local badge claim is upgraded.
+| Metric | Meaning |
+| --- | --- |
+| Final validation | Did the final app output satisfy schema, citations, urgency floors, and safety checks? |
+| Competence success | Did the configured model path, including allowed model repair, produce a competent case result? |
+| Raw configured-model success | Did first-pass model output work without repair? |
+| Focused repair success | Did a scoped model repair close a bounded failure? |
+| Deterministic patch count | How many final fields came from code scaffolding rather than model output? |
+| Full fallback use | Did the app abandon the model route and use deterministic fallback output? |
+| Expected-label success | Did the final output preserve case-level target labels such as urgency, source cards, and red flags? |
 
----
+Selected lineage on the 150-case field-workflow holdout:
+
+| Run | Competence | Raw success | Repair | Expected labels | Final validation | Fallback | Deterministic patches | Lesson |
+| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | --- |
+| v3 | 107/150 | 93/150 | 14 | 0/150 | 148/150 | 2 | 114 | First strong field-workflow jump, but weak observation ownership. |
+| v5 | 2/150 | 2/150 | 0 | 150/150 | 150/150 | 0 | 302 | The app passed; deterministic scaffolding carried too much. |
+| v6 | 142/150 | 142/150 | 0 | 146/150 | 150/150 | 0 | 21 | Targeted replay and delta rows moved model-owned behavior. |
+| v7 corrected | 148/150 | 148/150 | 0 | 147/150 | 150/150 | 0 | 3 | Remaining failures became narrow and inspectable. |
+| v10 | 147/150 | 147/150 | 0 | 150/150 | 150/150 | 0 | 6 | Some misses resisted generic corpus growth. |
+| v14p repair-union | 150/150 | 146/150 | 4 | 150/150 | 150/150 | 0 | 0 | Focused model repair closed the remaining corrected-holdout cases. |
+
+The corrected scoring view changes 6 cases from the original frozen holdout and preserves the correction manifest in `data/eval/field_workflow_holdout_v1_corrected_scoring_manifest.json`. The point is not to train around a bad target; it is to leave a receipt when a benchmark rule is corrected.
+
+## Public Artifacts
 
-## Getting Started
+- Demo Space: [build-small-hackathon/figment](https://huggingface.co/spaces/build-small-hackathon/figment)
+- Runtime URL: [build-small-hackathon-figment.hf.space](https://build-small-hackathon-figment.hf.space/)
+- Model archive: [build-small-hackathon/figment-finetuned-model-archive](https://huggingface.co/build-small-hackathon/figment-finetuned-model-archive)
+- Eval traces and SFT corpora: [build-small-hackathon/figment-eval-traces](https://huggingface.co/datasets/build-small-hackathon/figment-eval-traces)
+- Safety statement: [docs/safety_statement.md](docs/safety_statement.md)
+- Submission gates: [docs/submission_checklist.md](docs/submission_checklist.md)
+- Build Small org card: [docs/build-small-hackathon-org-card.md](docs/build-small-hackathon-org-card.md)
 
-Start with the full [prerequisites checklist](docs/prerequisites.md). The short version:
+The model archive contains the v1 pilot, v2-v4 checkpoints, and versioned v5-v14p BF16/GGUF artifacts. The dataset repo contains scored hosted/local traces plus synthetic SFT configs `figment_sft_v1` through `figment_sft_v14p`.
+
+## Quickstart
 
 ```bash
 python3 -m venv .venv
@@ -102,224 +148,128 @@ python -m pip install -r requirements.txt -r requirements-dev.txt
 cp .env.example .env
 ```
 
-### 1. Run the app with the hosted NVIDIA API
-
-Copy `.env.example` to `.env`, set the hosted model variables, and add `NVIDIA_API_KEY`. The hosted route uses the NVIDIA API Catalog OpenAI-compatible endpoint:
-
-```dotenv
-FIGMENT_MODE=hosted
-MODEL_BACKEND=hosted_omni
-MODEL_STACK=omni_native
-NVIDIA_BASE_URL=https://integrate.api.nvidia.com/v1
-NVIDIA_MODEL_ID=nvidia/nemotron-3-nano-omni-30b-a3b-reasoning
-NVIDIA_API_KEY=nvapi-...
-AUDIO_BACKEND=omni_native
-ENABLE_AUDIO_INTAKE=true
-```
-
-Then run:
+Or use the Makefile after creating the venv:
 
 ```bash
-make run-hosted-demo PYTHON=.venv/bin/python
+make install PYTHON=.venv/bin/python
 ```
 
-If the hosted model is unavailable or returns invalid JSON, Figment falls back to the deterministic canned navigator output and still validates the result.
-
-### 2. Run against a local OpenAI-compatible server
-
-To target a local OpenAI-compatible server after the Nemotron 3 Nano 4B path is verified, use the full BF16 4B model as the canonical local text artifact:
+Run the no-secret app path:
 
 ```bash
-vllm serve nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16 \
-  --served-model-name nemotron3-nano-4b-bf16 \
-  --trust-remote-code \
-  --max-model-len 16384
+MODEL_BACKEND=canned make run PYTHON=.venv/bin/python
 ```
 
-The full-weight snapshot has been downloaded locally at:
+Run the hosted Omni demo path:
 
-```text
-/Users/drake.thomsen/.cache/huggingface/hub/models--nvidia--NVIDIA-Nemotron-3-Nano-4B-BF16/snapshots/dfaf35de3e30f1867dd8dbc38a7fc9fb52d3914f
+```bash
+NVIDIA_API_KEY=nvapi-... make run-hosted-demo PYTHON=.venv/bin/python
 ```
 
-For a local run, expose that full-weight runtime through an OpenAI-compatible `/v1/chat/completions` endpoint and point Figment at it. Set `MODEL_BACKEND=llama_cpp`, `MODEL_STACK=local_4b_parakeet`, `LLAMA_BASE_URL=<local-openai-compatible-endpoint>/v1`, and `LOCAL_MODEL_ID=nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16` in `.env`. Do not count the local route as model competence until the 50-case eval records configured-model successes rather than full deterministic fallback.
-
-To capture the local evidence bundle once the endpoint is live:
+Run tests:
 
 ```bash
-PYTHON_DOTENV_DISABLED=true \
-python3 scripts/run_local_4b_evidence.py \
-  --base-url http://127.0.0.1:8001/v1
+PYTHONPATH=. .venv/bin/pytest tests -q
 ```
 
-The helper writes `/v1/models` metadata, one-case route smoke, eval JSONL, eval summary, and `eval_evidence_manifest.json` under `traces/local_4b_evidence_*`. The manifest captures model/server metadata, no-cloud route flags, raw/repair/full-fallback counts, field provenance, latency, and trace hashes. If the endpoint is unavailable or the route smoke falls back deterministically, it records that state and does not upgrade the local model claim.
+## Local Model Route
 
-To capture the local Parakeet ASR evidence bundle once a real local ASR adapter or device runtime produces provider output:
+Start a local OpenAI-compatible server, for example with a downloaded GGUF:
 
 ```bash
-PYTHON_DOTENV_DISABLED=true \
-python3 scripts/run_local_asr_evidence.py \
-  --provider-payload <local-parakeet-provider-output.json> \
-  --audio <optional-source-audio.wav>
+llama-server \
+  -m /path/to/figment-sft-v14p-lora-merged-bf16.bf16.gguf \
+  --host 127.0.0.1 \
+  --port 8001 \
+  -c 16384
 ```
 
-The ASR helper records Parakeet artifact metadata, optional audio metadata without copying raw audio, provider-output hash, Figment draft checks, and `asr_evidence_manifest.json`. Artifact presence alone does not count as local ASR proof.
-
-### 3. Canned fallback
-
-The scaffold can still run without any live model:
+Point Figment at it:
 
 ```dotenv
-MODEL_BACKEND=canned
+FIGMENT_MODE=local
+MODEL_STACK=local_4b_parakeet
+MODEL_BACKEND=llama_cpp
+LOCAL_MODEL_ID=nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16
+LLAMA_BASE_URL=http://127.0.0.1:8001/v1
+AUDIO_BACKEND=none
 ```
 
-### 4. Hosted demo target
-
-The submission Space target is under the **build-small-hackathon** Hugging Face org:
+Capture an evidence bundle once the endpoint is live:
 
-[build-small-hackathon/figment](https://huggingface.co/spaces/build-small-hackathon/figment)
-
-The submission target is a live Gradio demo powered by a hosted or self-hosted Nemotron Omni endpoint. Canned responses and traces are fallback only if hosted model, quota, or cold-start reliability fails. The public Space is now runnable in no-secret mode: the Hugging Face Space API reports `runtime.stage=RUNNING`, `app.py` is present, the Space serves HTTP 200, and the public Gradio API completed a typed pediatric-dehydration workflow with deterministic escalation and an honestly labeled `canned_backend` trace. Live hosted Omni generation in the public Space still needs a final demo trace if secrets are configured for judging; keep local/off-grid and small-model badge claims gated by the [submission checklist](docs/submission_checklist.md).
+```bash
+make smoke-local-model-route PYTHON=.venv/bin/python
+make local-4b-evidence PYTHON=.venv/bin/python
+```
 
-Related Hub assets in the same org:
+These commands write local evidence under `traces/`, which is generated and ignored by git.
 
-- Dataset and training corpora: [build-small-hackathon/figment-eval-traces](https://huggingface.co/datasets/build-small-hackathon/figment-eval-traces)
-- Fine-tuned local-model archive: [build-small-hackathon/figment-finetuned-model-archive](https://huggingface.co/build-small-hackathon/figment-finetuned-model-archive)
+## Training And Modal Eval
 
----
+Modal scripts are included for the full train, merge, upload, and eval loop. They require Modal auth, appropriate secrets, and enough storage for model artifacts.
 
-## Repository layout
+```bash
+.venv/bin/modal run modal/finetune_figment_nemotron.py --smoke true
+.venv/bin/modal run modal/finetune_figment_nemotron.py
+.venv/bin/modal run modal/eval_figment_nemotron.py
+```
 
-This repo now holds the runnable scaffold plus the planning docs. Current structure:
+The high-level loop is:
 
-```text
-figment/
-  app.py                # Gradio Server app and custom frontend
-  figment/              # config, schemas, rules, retrieval, model_client,
-                        #   prompt_builder, validators, trace, sbar
-  data/
-    protocol_cards/     # 10 prototype cards (JSON)
-    demo_audio/         # three synthetic dictated-intake WAV clips for the demo
-  scripts/              # FTS build, smoke, and eval helpers
-  traces/               # exported demo traces
-  docs/                 # field notes, model/dataset/safety cards, this plan
-```
+1. generate or replay synthetic harness-shaped rows;
+2. verify rows against the real prompt, validators, retrieval, and expected-label rules;
+3. stage train/validation splits for Modal;
+4. train a LoRA adapter on H100;
+5. merge into BF16, convert to GGUF, and serve locally;
+6. rerun the field-workflow holdout;
+7. compare raw, repair, patch, fallback, expected-label, final-validation, and latency metrics.
 
-Available now:
+## Repository Layout
 
 ```text
-app.py                                        # Gradio app scaffold
-figment/                                      # protocol engine, model/audio adapters, trace/validators
-data/protocol_cards/                          # 10 prototype protocol cards
-data/demo_audio/                              # click-to-load hosted audio demo clips
-traces/                                       # regenerated demo traces
-tests/                                        # regression tests for safety, audio, rules, app smoke
-docs/figment-workback-plan.md                 # the full day-by-day build plan
-docs/build-small-hackathon-org-card.md         # hackathon rules (source of truth)
-docs/prerequisites.md                          # setup contract for local, hosted, and Modal work
-docs/superpowers/specs/  docs/superpowers/plans/  # design spec + implementation plan for plan additions
-requirements.txt / requirements-dev.txt / .env.example
+app.py                  Gradio Server app and API surface
+figment/                config, schemas, rules, retrieval, prompt, model clients,
+                        navigator, validators, repair, provenance, traces
+data/protocol_cards/    10 prototype protocol cards
+data/eval/              hosted and field-workflow eval cases plus manifests
+data/demo_audio/        synthetic dictated-intake demo clips
+scripts/                eval, smoke, evidence, generation, merge, and claim audit helpers
+modal/                  Modal training, merge, upload, and H100 eval entrypoints
+tests/                  regression tests for runtime, safety, eval, data plans, and gates
+docs/                   plans, evidence notes, safety, submission, and public drafts
 ```
 
-Key docs: [workback plan](docs/figment-workback-plan.md) · [adversarial review action items](docs/adversarial-review-action-items.md) · [hosted eval results](docs/hosted_omni_eval_results.md) · [parameter/evidence ledger](docs/model_parameter_evidence_ledger.md) · [local llama evidence](docs/local_llama_eval_evidence.md) · [local Parakeet ASR evidence](docs/local_parakeet_asr_evidence.md) · [submission checklist](docs/submission_checklist.md) · [safety statement](docs/safety_statement.md) · [user test notes](docs/user_test_notes.md) · [prerequisites](docs/prerequisites.md) · [hackathon rules](docs/build-small-hackathon-org-card.md) · [design spec](docs/superpowers/specs/2026-06-05-figment-plan-additions-design.md) · [implementation plan](docs/superpowers/plans/2026-06-05-figment-plan-additions.md).
-
----
-
-## Data & evaluation
-
-- **Synthetic data, not memorized facts.** Future 5,000–10,000 candidate cases are generated by teacher models (Mistral/MiniMax, build-time only), cross-critiqued, and filtered by a deterministic validator down to ~2,000–4,000 kept examples. No real PHI is used.
-- **Behavior, not knowledge.** Training teaches the model to cite cards, ask for missing info, escalate red flags, produce SBAR, and refuse unsafe requests.
-- **Eval before training.** A 50-case hosted Omni eval now scores the model on measurable behavior, while the larger 50-100 case target thresholds remain the quality bar:
-
-| Metric | Target |
-| ------ | -----: |
-| Valid JSON | ≥ 98% |
-| Source-card citation rate | ≥ 95% |
-| Red-flag recall | ≥ 90% |
-| Unsupported diagnosis rate | 0% |
-| Unsupported medication/dose rate | 0% |
-| Missing-info question rate | ≥ 85% |
-| SBAR factuality | ≥ 95% |
-| Prompt-injection compliance failure | 0 critical |
-
-Current measured hosted Omni results are in [hosted_omni_eval_results.md](docs/hosted_omni_eval_results.md). The baseline run reached **28/50** whole-output model competence with **22/50** full deterministic fallback and **50/50** final validation. The load-bearing follow-up reached **31/50** whole-output model competence, **8/50** full fallback, **480/650** model-retained fields, **170/650** deterministic patches, and **50/50** final validation. Final validation is application safety, not pure model competence; deterministic fallback and deterministic patches are reported separately and cannot inflate model scores.
+Generated or heavyweight paths such as `traces/`, `data/finetune/`, `tools/`, checkpoints, weights, and local artifacts are intentionally ignored. Use the public Hub archives for shareable model, trace, and corpus artifacts.
 
-Local 4B + Parakeet eval, no-cloud/off-grid proof, and any fine-tuned adapter eval are still unmeasured.
+## Data Handling
 
-The current eval harness records strict validation, repair/fallback, field provenance, and latency. Judgment metrics can still be added with a held-out judge model once the larger gold set exists.
+- Demo and eval scenarios are synthetic or de-identified.
+- Do not enter real PHI into the hosted demo.
+- Hosted mode may send synthetic or de-identified text/audio to the configured hosted endpoint.
+- Local mode is intended to keep runtime inputs on the local machine.
+- Figment traces do not retain raw audio bytes, uploaded filenames, local secrets, or unnecessary identifying details.
 
----
-
-## Safety & non-goals
+## Safety And Non-Goals
 
-Figment is deliberately scoped. **It will not:**
+Figment will not:
 
-- **diagnose** — it surfaces protocol cards and danger signs; it does not name a condition as fact;
-- **prescribe or dose medication** — doses appear only if a cited card contains them;
-- **replace a clinician** — the trained responder remains the decision-maker;
-- **serve untrained users** — it is a tool for trained responders;
-- **store PHI or raw audio** — traces scrub raw audio-like payloads and uploaded filenames;
-- **hide hosted-mode data flow** — hosted Space mode may send synthetic or de-identified text/audio to the configured Omni endpoint, while local mode keeps runtime inputs on the local machine;
-- **act autonomously** — every output is advisory and requires human judgment.
+- diagnose a condition as fact;
+- prescribe medication or provide doses beyond cited protocol-card content;
+- replace clinician, supervisor, or trained responder judgment;
+- hide fallback, deterministic patches, or model repair;
+- use unconfirmed audio fields for final navigation;
+- present local/off-grid, local ASR, target-user, or final submission claims without the corresponding evidence gate.
 
-This posture reflects real risk: the WHO has warned that authoritative-sounding health AI can create automation bias, and the FDA regulates clinical-decision-support software depending on its claims and users. Figment makes no clinical claims. See the fuller [safety statement](docs/safety_statement.md).
-
----
+See [docs/safety_statement.md](docs/safety_statement.md) for the fuller intended-use and non-goal statement.
 
-## Licensing & data handling
+## License
 
 | Artifact | License |
-| -------- | ------- |
-| Model / adapter | inherits the NVIDIA Nemotron model license; cite exact upstream terms in the model card |
-| Synthetic dataset | CC-BY-4.0 |
+| --- | --- |
 | Code | [Apache-2.0](LICENSE) |
-
-Data handling: local mode keeps runtime inputs on the local machine; hosted mode is for synthetic or de-identified demo inputs only; traces do not retain raw audio.
-
----
-
-## Demo cases
-
-Three canonical cases drive the demo:
-
-1. **Pediatric dehydration** — missing vitals, urgent red flags, asks next questions, produces a referral note.
-2. **Wound infection after disaster injury** — protocol retrieval, avoids antibiotic overreach, recommends escalation criteria, clean documentation.
-3. **Pregnancy danger sign** — deterministic red-flag override, immediate escalation, minimal model freelancing.
-
-The Intake tab includes click-to-load audio examples for all three cases when `data/demo_audio/*.wav` is present. These are synthetic Voxtral-generated dictated-intake clips; they are not real patient audio.
-
----
-
-## Hackathon
-
-Built for the **[Build Small Hackathon](docs/build-small-hackathon-org-card.md)** (Gradio · Hugging Face), which caps models at 32B parameters and requires a Gradio app hosted as a Hugging Face Space plus a demo video and social post.
-
-Submission claims are evidence-gated:
-
-| Claim / badge area | Current status | Proof needed before claiming achieved |
-| ------------------ | -------------- | ------------------------------------- |
-| Hosted Gradio Space | Runnable in no-secret canned-fallback mode; live hosted-model demo trace still proof-needed | Public Space app files present, cold boot, typed intake run, trace showing `raw_route=canned`, `final_route=canned_backend`, `validation_status=passed`, and `raw_audio_stored=false` |
-| Backyard AI | Targeted / proof-needed | A real trained responder using synthetic or de-identified scenarios, recorded in [user test notes](docs/user_test_notes.md) |
-| Off the Grid | Targeted, not yet proven | Recorded no-cloud run using either self-hosted Omni on adequate local hardware or the smaller verified local stack |
-| Llama Champion | Targeted, not yet proven | Working eligible local model route with trace/eval evidence |
-| Sharing is Caring | Targeted / proof-needed | Public Space, repo, demo video, and social post links |
-| Well-Tuned | Stretch / proof-needed | Eval harness plus measured improvement from tuning or an adapter, not fallback output |
-| Field Notes | Tentative / proof-needed | Submission rules confirmation plus field-note artifact |
-| Off-Brand | Targeted / proof-needed | Final demo/story asset aligned to organizer criteria |
-
----
+| Synthetic/de-identified dataset artifacts | CC-BY-4.0 where published |
+| Model artifacts | NVIDIA Nemotron Open Model License inherited from `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16` |
 
 ## Acknowledgements
 
-- **NVIDIA** — Nemotron 3 Nano Omni model · **Modal** — fine-tune/eval compute · **Gradio** & **Hugging Face** — app framework and hosting · **llama.cpp** — local inference.
-
----
-
-## Disclaimer
-
-Figment is a **prototype for trained responders**, not medical advice and not a medical device. It does not diagnose or prescribe. Protocol cards are prototypes derived from public guideline concepts, **not** clinical guidelines. Always rely on qualified clinical judgment and local protocols.
-
-<!-- TODO before submission:
-  - Add a LICENSE file.
-  - Add the demo video + social post links.
--->
+Figment was built for the [Build Small Hackathon](docs/build-small-hackathon-org-card.md), hosted by Gradio and Hugging Face, with NVIDIA and Modal central to the model and training loop. It also depends on Gradio Server, Hugging Face Hub, Modal, llama.cpp-compatible serving, and the small-model debugging discipline made visible by the eval traces.

docs/adversarial-review-action-items.md

@@ -8,7 +8,7 @@ Important nuance: the current Omni-first architecture can technically support an
 
 ## 1. Make the Hugging Face Space actually runnable
 
-Current risk: the Space exists, but the public Space API showed `runtime.stage=NO_APP_FILE` and only `.gitattributes` plus `README.md` in the remote Space. That fails the required hosted Gradio artifact even if the local repo is healthy.
+Current status: the Space now cold-boots in no-secret canned-fallback mode. On 2026-06-07 the public Space API reported `runtime.stage=RUNNING`, `sdk=gradio`, `sha=5dcfc5c830de7331eca9020b17e1c571a8619654`, 92 siblings, and `app.py` present; the Space URL served HTTP 200. A public Gradio API smoke loaded typed intake, fired deterministic pediatric-dehydration escalation, retrieved protocol cards, and returned an honestly labeled `canned_backend` trace with `validation_status=passed` and `raw_audio_stored=false`.
 
 Fix direction:
 - Push the full Gradio app, requirements, protocol cards, and demo assets to `build-small-hackathon/figment`.
@@ -16,9 +16,9 @@ Fix direction:
 - Align Space metadata and dependency versions with the local repo.
 
 Done when:
-- The public Space boots to the Figment Gradio UI.
-- The Space can run typed intake with canned fallback and trace labeling when secrets are absent.
-- Hosted Omni mode works when secrets are present, or failure is clearly labeled.
+- [x] The public Space boots to the Figment Gradio UI.
+- [x] The Space can run typed intake with canned fallback and trace labeling when secrets are absent.
+- [ ] Hosted Omni mode works when secrets are present, or failure is clearly labeled in a final demo trace.
 
 ## 2. Make live model contribution visible
 

docs/figment-workback-plan.md

@@ -12,7 +12,7 @@ The hackathon target:
 
 > Ship a polished Gradio Space by **June 15**, with a hosted Nemotron Omni-powered app, a local/offline Nemotron 3 Nano 4B + Parakeet path, an open synthetic dataset if time allows, demo traces, and a field-notes writeup. Fine-tuning should target the smaller 4B local model first; Omni fine-tuning is deferred unless the runtime demo, safety validation, local/offline proof, and 4B adapter story are already green.
 
-Architecture note: **Nemotron Omni remains the hosted v1 default and submission demo story**. The on-device/off-grid target is now **NVIDIA Nemotron 3 Nano 4B BF16** for text navigation and fine-tuning, paired with **Parakeet RNNT 1.1B** for offline ASR. The old 30B text-plus-Parakeet split is no longer the preferred local path.
+Architecture note: **Nemotron Omni remains the hosted v1 default and submission demo story**. The local/off-grid target is now **NVIDIA Nemotron 3 Nano 4B BF16** for text navigation and fine-tuning, paired with **Parakeet RNNT 1.1B** for offline ASR. The old 30B text-plus-Parakeet split is no longer the preferred local path.
 
 The Build Small Hackathon rules require models at or below **32B parameters**, a **Gradio app hosted as a Hugging Face Space**, plus a Space link, demo video, and social post for submission. The bonus badges you should target are **Off the Grid**, **Well-Tuned**, **Llama Champion**, **Sharing is Caring**, **Field Notes**, and, if time allows, **Off-Brand** custom UI. ([Hugging Face][1])
 
@@ -101,7 +101,7 @@ Draft on June 5, finalize June 14. Required elements:
 
 # 2. Hardware and runtime plan
 
-Hosted Omni is a clean demo story but a harder on-device runtime story. Treat this honestly: build the app around hosted Omni first, then make the local/off-grid proof lighter with Nemotron 3 Nano 4B plus Parakeet.
+Hosted Omni is a clean demo story but a harder local runtime story. Treat this honestly: build the app around hosted Omni first, then make the local/off-grid proof lighter with Nemotron 3 Nano 4B plus Parakeet.
 
 Official Omni weight/runtime facts:
 
@@ -124,7 +124,7 @@ The 4B model is text-only, so it does not replace hosted Omni's native audio/mul
 
 Use:
 
-* **NVIDIA-Nemotron-3-Nano-4B-BF16** as the on-device text-navigation and fine-tuning target
+* **NVIDIA-Nemotron-3-Nano-4B-BF16** as the local text-navigation and fine-tuning target
 * **Parakeet RNNT 1.1B** as the offline ASR target
 * **16k context** for normal usage, despite the model card's much longer maximum context
 * **8k context** fallback if latency or memory gets weird
@@ -324,7 +324,7 @@ Deliberate scope boundaries, stated up front so judges and users know exactly wh
 * It will **not prescribe or dose medication** — drug doses appear only if a cited protocol card contains them.
 * It will **not replace a clinician** — it supports escalation and documentation; the trained responder remains the decision-maker.
 * It is **not for untrained users** — the intended user is a trained responder (see the safety statement in §1).
-* It does **not store PHI** — local/offline mode keeps patient inputs on-device, hosted demo mode uses synthetic/de-identified inputs only, and published traces never include raw audio (see §5).
+* It does **not store PHI** — local/offline mode keeps patient inputs on the local machine, hosted demo mode uses synthetic/de-identified inputs only, and published traces never include raw audio (see §5).
 * It is **not autonomous** — every output is advisory and requires human judgment.
 * It will **not override deterministic danger signs** — red-flag rules set the minimum urgency floor.
 * It will **not invent protocol pathways, treatments, or referral criteria** beyond cited cards.
@@ -561,7 +561,7 @@ Offline ASR:     Parakeet RNNT is CC-BY-4.0; include attribution if the local AS
 
 Data handling:
 
-* Local/offline mode processes patient inputs on-device.
+* Local/offline mode processes patient inputs locally.
 * Hosted Space mode may transmit text/audio inputs to the hosted Omni endpoint; use synthetic or de-identified demo inputs only in hosted mode.
 * Training data is **synthetic with no real PHI** (reaffirms the §6 generator rule); demo cases are fictional.
 * Audio demo clips are synthetic responder dictation only; do not use real patient audio.

docs/local_llama_eval_evidence.md

@@ -4,9 +4,22 @@ Date: 2026-06-07
 
 This note separates local llama.cpp evidence from hosted Omni evidence and from canned deterministic fallback.
 
-## Current endpoint check
+## Full-weight local artifact
 
-No local OpenAI-compatible llama.cpp endpoint was active during this Worker C pass.
+The canonical local text artifact is the full BF16 4B model, not a quantized GGUF:
+
+- Model repo: `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16`
+- Revision: `dfaf35de3e30f1867dd8dbc38a7fc9fb52d3914f`
+- Local snapshot path: `/Users/drake.thomsen/.cache/huggingface/hub/models--nvidia--NVIDIA-Nemotron-3-Nano-4B-BF16/snapshots/dfaf35de3e30f1867dd8dbc38a7fc9fb52d3914f`
+- Resolved snapshot size: `7.4G`
+- Full weight file: `model.safetensors`
+- Weight file size: `7947142640` bytes
+- Weight file SHA-256: `55d4e2519456c4a9bddf596b0748d630e3b2ce6ff6f4c2b7ed3e07e2b00dad42`
+- Required companion files present: `config.json`, `tokenizer.json`, `tokenizer_config.json`, `chat_template.jinja`, `modeling_nemotron_h.py`, `configuration_nemotron_h.py`
+
+This download proves local artifact availability only. It does not prove local model competence, Off the Grid, Llama Champion, or local ASR until a real local OpenAI-compatible endpoint runs through the Figment eval without full deterministic fallback.
+
+## Endpoint checks
 
 Checked:
 
@@ -17,6 +30,43 @@ curl -fsS --max-time 2 http://127.0.0.1:8001/v1/models
 
 Observed: no listener on port `8001`; `curl` failed to connect to `127.0.0.1:8001`.
 
+Rechecked after downloading the full BF16 artifact on 2026-06-07:
+
+```bash
+curl -fsS --max-time 2 http://127.0.0.1:8001/v1/models
+```
+
+Observed:
+
+- `curl: (7) Failed to connect to 127.0.0.1 port 8001`
+
+Local 4B, Off the Grid, and Llama Champion claims remain proof-needed. The next real step is to run the full BF16 model on a local OpenAI-compatible endpoint, record `/v1/models`, then run the 50-case eval below.
+
+## Discarded quantized side check
+
+A mistaken Q4 GGUF smoke was attempted before the full-weight requirement was clarified. It proved only that Figment could reach a local OpenAI-compatible endpoint; the model output failed navigator validation and fell back deterministically, so it does not count as route proof or model competence. The Q4 cache created by that attempt was removed.
+
+## Evidence bundle command
+
+Prefer the bundled helper once the local endpoint is live:
+
+```bash
+PYTHON_DOTENV_DISABLED=true \
+python3 scripts/run_local_4b_evidence.py \
+  --base-url <local-openai-compatible-endpoint>/v1
+```
+
+The helper writes a timestamped evidence directory under `traces/local_4b_evidence_*`:
+
+- `endpoint_metadata.json`: `/v1/models` response or connection error
+- `route_smoke.json`: one-case configured-route smoke result
+- `local_4b_eval.jsonl`: 50-case eval records, only after the route smoke proves configured-model validation unless `--force-eval` is used
+- `eval_summary.json`: model competence, fallback, provenance, and final validation counts
+- `eval_evidence_manifest.json`: compact evidence manifest with model/server metadata, no-cloud route flags, raw/repair/full-fallback counts, field provenance, latency summary, eval-file hash, and per-case trace hashes
+- `summary.json`: top-level status and whether the evidence counts as route proof or 50-case local competence
+
+Exit codes are intentionally evidence-gated: `0` for a completed eval or passed smoke-only run, `2` for endpoint unavailable, and `1` when the route smoke fails and eval is skipped. Endpoint availability alone must not be counted as model competence.
+
 ## One-case route smoke
 
 Use this only to prove the app can call the configured local route. A passed smoke is not a 50-case local competence run.
@@ -26,7 +76,7 @@ FIGMENT_MODE=local \
 MODEL_STACK=local_4b_parakeet \
 MODEL_BACKEND=llama_cpp \
 LOCAL_MODEL_ID=nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16 \
-LLAMA_BASE_URL=http://127.0.0.1:8001/v1 \
+LLAMA_BASE_URL=<local-openai-compatible-endpoint>/v1 \
 FIGMENT_SMOKE_ALLOW_NETWORK=true \
 PYTHON_DOTENV_DISABLED=true \
 python3 scripts/smoke_model_route.py
@@ -36,14 +86,14 @@ The smoke output now includes `local_llm_evidence.proof_status`, `counts_as_no_c
 
 ## Real 50-case eval command
 
-Run this only after starting a real local OpenAI-compatible llama.cpp server and recording `/v1/models` metadata.
+Run this directly only after starting a real local OpenAI-compatible server and recording `/v1/models` metadata. The bundled helper above runs the same eval after a passing route smoke.
 
 ```bash
 FIGMENT_MODE=local \
 MODEL_STACK=local_4b_parakeet \
 MODEL_BACKEND=llama_cpp \
 LOCAL_MODEL_ID=nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16 \
-LLAMA_BASE_URL=http://127.0.0.1:8001/v1 \
+LLAMA_BASE_URL=<local-openai-compatible-endpoint>/v1 \
 PYTHON_DOTENV_DISABLED=true \
 python3 scripts/run_eval.py \
   --backend llama_cpp \
@@ -54,4 +104,4 @@ python3 scripts/run_eval.py \
   --output traces/local_llama_cpp_eval_$(date -u +%Y%m%dT%H%M%SZ).jsonl
 ```
 
-A real local evidence bundle should include the eval JSONL trace, the printed summary, `/v1/models` response or equivalent server metadata, model file/hash or server launch command, and confirmation that no hosted model credentials were required for the run.
+A real local evidence bundle should include the eval JSONL trace, `eval_evidence_manifest.json`, `/v1/models` response or equivalent server metadata, model file/hash or server launch command, and confirmation that no hosted model credentials were required for the run.

docs/model_parameter_evidence_ledger.md

@@ -6,9 +6,9 @@ Purpose: keep parameter, route, locality, adapter, ASR, and organizer-confirmati
 
 ## Current Claim Boundary
 
-- Hosted Omni has measured eval evidence, but not public Space cold-boot evidence.
-- The public Space target exists, but the last known public API state was `runtime.stage=NO_APP_FILE` with only metadata files present. Do not call the public Space runnable until it is verified from the Space URL.
-- The local 4B + Parakeet route is the preferred no-cloud/off-grid proof path, but it is not yet proven with a real local 50-case eval or local ASR smoke.
+- Hosted Omni has measured eval evidence through the eval harness. The public Space is now verified runnable in no-secret canned-fallback mode, but that public Space proof is not live hosted Omni generation evidence.
+- The public Space target exists and cold-boots from the Space URL. Current public API evidence: `runtime.stage=RUNNING`, `sdk=gradio`, `sha=5dcfc5c830de7331eca9020b17e1c571a8619654`, 92 siblings, and `app.py` present. Public workflow evidence: typed intake, deterministic pediatric-dehydration escalation, protocol retrieval, `raw_route=canned`, `final_route=canned_backend`, `validation_status=passed`, `raw_audio_stored=false`, and zero model-retained fields.
+- The local 4B + Parakeet route is the preferred no-cloud/off-grid proof path. The full BF16 4B artifact is now downloaded locally, but the route is not yet proven with a real local 50-case eval or local ASR smoke.
 - No published Figment adapter is recorded yet. Well-Tuned remains a stretch claim until a published fine-tuned model or adapter is used by the app and measured.
 - Organizer confirmation is still needed for the Omni 31B body-count versus 33B sidebar ambiguity and for any additive local stack or adapter-count interpretation.
 
@@ -18,15 +18,15 @@ Purpose: keep parameter, route, locality, adapter, ASR, and organizer-confirmati
 | --- | --- | --- | --- | --- | --- | --- | --- | --- |
 | Hosted Omni primary | `nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16`; API route `nvidia/nemotron-3-nano-omni-30b-a3b-reasoning` | NVIDIA model-card body: 31B total parameters; HF sidebar has been observed as 33B in planning docs | Roughly 3B active parameters per token is a runtime/MoE note, not the compliance number | None used in current evals | Native Omni speech encoder is part of the Omni model-card count; no separate ASR model is claimed for hosted Omni | Hosted NVIDIA API route in current evals; self-hosted no-cloud route not recorded | Pending: ask organizers whether model-card body count is acceptable if sidebar count differs | Baseline eval: 28/50 whole-output competence, 22/50 full fallback, 50/50 final validation. Follow-up eval: 31/50 competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, 50/50 final validation |
 | Self-hosted Omni no-cloud target | `nvidia/Nemotron-3-Nano-Omni-30B-A3B-Reasoning-BF16`, FP8, or NVFP4 variant if served locally | Same Omni 31B body-count claim, with same 33B sidebar ambiguity | Active parameters do not decide compliance | None recorded | Native Omni audio if used locally; included in Omni count if organizers accept the model-card count | Would be local/self-hosted only if served with no runtime cloud APIs | Pending for count ambiguity and hardware/runtime proof | No recorded no-cloud eval or public demo trace yet. Do not claim Off the Grid achieved |
-| Local 4B + Parakeet proof path | Text: `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16`; ASR: `nvidia/parakeet-rnnt-1.1b`; local route `MODEL_BACKEND=llama_cpp`, `MODEL_STACK=local_4b_parakeet` | Workback model-card notes: 3.97B text model plus about 1.1B Parakeet, roughly 5.1B nominal before adapters | No active-parameter substitution; use additive total-count story if organizers require stack accounting | None recorded yet; exact adapter count must be measured before any Well-Tuned or compliance upgrade | About 1.1B for Parakeet RNNT ASR, only if real local ASR is enabled and proven | Intended local OpenAI-compatible endpoint on `127.0.0.1` plus local ASR; no-cloud only after recorded proof | Pending: confirm additive multi-model counting and adapter counting | Configured/labeled path only. No real local 50-case eval, no local ASR smoke, and no trace hash recorded yet |
+| Local 4B + Parakeet proof path | Text: `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16`; ASR: `nvidia/parakeet-rnnt-1.1b`; local route `MODEL_BACKEND=llama_cpp`, `MODEL_STACK=local_4b_parakeet` | Workback model-card notes: 3.97B text model plus about 1.1B Parakeet, roughly 5.1B nominal before adapters | No active-parameter substitution; use additive total-count story if organizers require stack accounting | None recorded yet; exact adapter count must be measured before any Well-Tuned or compliance upgrade | About 1.1B for Parakeet RNNT ASR, only if real local ASR is enabled and proven | Intended local OpenAI-compatible endpoint serving the full BF16 model plus local ASR; no-cloud only after recorded proof | Pending: confirm additive multi-model counting and adapter counting | Full BF16 4B snapshot downloaded at repo revision `dfaf35de3e30f1867dd8dbc38a7fc9fb52d3914f`; `model.safetensors` is `7947142640` bytes with SHA-256 `55d4e2519456c4a9bddf596b0748d630e3b2ce6ff6f4c2b7ed3e07e2b00dad42`. Parakeet artifact downloaded at repo revision `a07b19e98a26c1873a3f2622c446a4a1ca6316cb`; `parakeet-rnnt-1.1b.nemo` is `4283105280` bytes with SHA-256 `535896f014953d945b287ac533560e20da8103c6781b152de4645528e2b60738`. No real local 50-case eval, no local ASR provider proof, and no trace hash recorded yet |
 | 4B Figment adapter stretch | Planned adapter name: `nvidia-nemotron-3-nano-4b-figment-lora-v1` | Base model count is 3.97B; adapter count must be added or documented per organizer guidance | Not applicable | Pending. Record exact trainable and published adapter parameter count before claiming | Parakeet count applies only if adapter demo also uses local ASR | Local route or published HF model route, depending on final artifact | Pending for adapter accounting and Well-Tuned eligibility | Not trained, published, or measured in this ledger |
-| Canned fallback | No live model | Not a model-compliance artifact | Not applicable | Not applicable | Not applicable | Local deterministic fallback | Not applicable | Useful for safety and cold-start fallback only. Cannot count as model competence, Off the Grid proof, Llama Champion proof, or Well-Tuned proof |
+| Canned fallback | No live model | Not a model-compliance artifact | Not applicable | Not applicable | Not applicable | Local deterministic fallback; public Space no-secret fallback verified | Not applicable | Useful for safety, deployment health, and cold-start fallback only. Cannot count as model competence, Off the Grid proof, Llama Champion proof, or Well-Tuned proof |
 
 ## Submission Gates
 
 | Claim | Required upgrade evidence |
 | --- | --- |
-| Public Space runnable | Public Space app files present, clean cold boot from the Space URL, typed intake run, and trace showing actual route/fallback status |
+| Public Space runnable | Satisfied for no-secret canned-fallback mode at Space commit `5dcfc5c830de7331eca9020b17e1c571a8619654`: app files present, clean cold boot from the Space URL, typed intake run, and trace showing actual route/fallback status |
 | Hosted model load-bearing | Cite hosted eval metrics separately from final validation: 31/50 whole-output competence and 480/650 model-retained fields in the follow-up run |
 | <=32B hosted Omni compliance | Organizer accepts the 31B model-card body count or the submission falls back to a clearly eligible smaller route |
 | Off the Grid | Recorded no-cloud run with trace evidence, either self-hosted Omni or local 4B + Parakeet/typed intake |

docs/safety_statement.md

@@ -26,7 +26,7 @@ The trained responder remains responsible for judgment and action. Figment outpu
 
 The submission should use synthetic or de-identified scenarios only. Do not enter real PHI into the hosted demo.
 
-Local mode is intended to keep runtime inputs on-device. Hosted mode may send synthetic or de-identified text or audio to the configured Omni endpoint. Traces should not retain raw audio, uploaded filenames, or unnecessary identifying details.
+Local mode is intended to keep runtime inputs on the local machine. Hosted mode may send synthetic or de-identified text or audio to the configured Omni endpoint. Traces should not retain raw audio, uploaded filenames, or unnecessary identifying details.
 
 ## Off-Grid Claim Boundary
 

docs/smaller-llm-load-bearing-action-plan.md

@@ -15,95 +15,105 @@ This note captures the adversarial review items from the Build Small Hackathon r
 
 ## Current Evidence Snapshot
 
-- Local tests passed before this note was written: `python3 -m pytest -q` reported `105 passed`.
+- Local tests passed after the fanout/integration pass, evidence-manifest updates, claim-audit guard, and evidence-gate report: `python3 -m pytest -q` reported `133 passed`.
 - Hosted Omni baseline eval: `28/50` whole-output competence, `22/50` full deterministic fallback, `50/50` final validation.
 - Hosted Omni load-bearing follow-up eval: `31/50` whole-output competence, `8/50` full fallback, `480/650` model-retained fields, `170/650` deterministic patches, `50/50` final validation.
-- Public Space API still reported `runtime.stage=NO_APP_FILE` with only `.gitattributes` and `README.md`.
-- Local 4B and Parakeet paths are configured or labeled, but not yet proven with real no-cloud eval or ASR evidence.
+- Public Space cold boot is now verified in no-secret canned-fallback mode at Space commit `5dcfc5c830de7331eca9020b17e1c571a8619654`: Space API `runtime.stage=RUNNING`, `app.py` present, HTTP 200, typed intake workflow, deterministic pediatric-dehydration escalation, protocol retrieval, and trace route `raw_route=canned` / `final_route=canned_backend` with `validation_status=passed` and `raw_audio_stored=false`.
+- The full-weight local 4B text artifact is now downloaded: `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16` at commit `dfaf35de3e30f1867dd8dbc38a7fc9fb52d3914f`, with `model.safetensors` size `7947142640` bytes and SHA-256 `55d4e2519456c4a9bddf596b0748d630e3b2ce6ff6f4c2b7ed3e07e2b00dad42`. Local 4B and Parakeet paths are still not proven with a real no-cloud 50-case eval or local ASR evidence.
+- Local evidence capture is now scripted via `scripts/run_local_4b_evidence.py`; it records endpoint metadata, route smoke, eval records, eval summary, `eval_evidence_manifest.json`, and gated proof flags.
+- The local Parakeet ASR artifact is now downloaded: `nvidia/parakeet-rnnt-1.1b` at commit `a07b19e98a26c1873a3f2622c446a4a1ca6316cb`, with `parakeet-rnnt-1.1b.nemo` size `4283105280` bytes and SHA-256 `535896f014953d945b287ac533560e20da8103c6781b152de4645528e2b60738`. ASR evidence capture is scripted via `scripts/run_local_asr_evidence.py`, including `asr_evidence_manifest.json`, but no real local ASR provider payload has passed yet.
+- Submission-facing claim drift is now audited by `scripts/audit_submission_claims.py` / `make audit-claims`; the current audit passes while keeping Off the Grid, Llama Champion, Well-Tuned, Backyard user-use, local 4B competence, local ASR, demo video, and social post gates false.
+- Evidence-gate status is now reportable via `scripts/evidence_gate_status.py` / `make evidence-gates`; it currently marks public Space, hosted Omni eval, and claim audit as present, and keeps local 4B 50-case eval, no-cloud route, Llama Champion route, local ASR provider proof, trained-responder user test, demo video, social post, and Well-Tuned adapter incomplete.
 
 ## Work Items
 
 ### 1. Make the public Hugging Face Space runnable
 
-- [ ] Push the full Gradio app, requirements, protocol cards, demo assets, and README to `build-small-hackathon/figment`.
-- [ ] Verify a public cold boot from the Space URL, not only local startup.
-- [ ] Record Space evidence in `docs/submission_checklist.md`.
-- [ ] Ensure no-secret mode cold-boots with typed intake, honest canned fallback, and trace labeling.
+- [x] Push the full Gradio app, requirements, protocol cards, demo assets, and README to `build-small-hackathon/figment`.
+- [x] Verify a public cold boot from the Space URL, not only local startup.
+- [x] Record Space evidence in `docs/submission_checklist.md`.
+- [x] Ensure no-secret mode cold-boots with typed intake, honest canned fallback, and trace labeling.
 
 ### 2. Add a parameter and evidence ledger
 
-- [ ] Create a compact ledger with model ID, route, total-parameter source, active-parameter note, adapter parameter count, ASR companion count, endpoint locality, and organizer-confirmation status.
-- [ ] Explicitly mark active parameters as not the compliance number.
-- [ ] Include the Omni 31B body-count versus 33B sidebar ambiguity.
-- [ ] Include the local 4B + Parakeet additive story and adapter headroom.
+- [x] Create a compact ledger with model ID, route, total-parameter source, active-parameter note, adapter parameter count, ASR companion count, endpoint locality, and organizer-confirmation status.
+- [x] Explicitly mark active parameters as not the compliance number.
+- [x] Include the Omni 31B body-count versus 33B sidebar ambiguity.
+- [x] Include the local 4B + Parakeet additive story and adapter headroom.
 
 ### 3. Prove the smaller local LLM path separately
 
+- [x] Download the full-weight `nvidia/NVIDIA-Nemotron-3-Nano-4B-BF16` artifact for the local route.
+- [x] Add an evidence-bundle helper for the local endpoint.
 - [ ] Run the 50-case eval through `MODEL_BACKEND=llama_cpp` against a real local OpenAI-compatible endpoint.
-- [ ] Record model/server metadata, no-cloud evidence, raw success, repair success, full fallback, field provenance, latency, and trace hashes.
-- [ ] Add a run note that distinguishes local 4B evidence from hosted Omni evidence.
-- [ ] Ensure whole fallback cannot count as local model competence.
+- [ ] Record model/server metadata, no-cloud evidence, raw success, repair success, full fallback, field provenance, latency, and trace hashes. The helper now generates `eval_evidence_manifest.json` with these fields after a completed local eval; the item remains unchecked until a real local run exists.
+- [x] Add a run note that distinguishes local 4B evidence from hosted Omni evidence.
+- [x] Ensure whole fallback cannot count as local model competence.
 
 ### 4. Publish model scorecards separate from app safety
 
-- [ ] Treat `final_validation_successes` as app safety, not model competence.
-- [ ] Publish raw-only, repaired, hybrid, full-fallback, and per-field scorecards.
-- [ ] Update stale README and checklist language that still says no full eval has run.
-- [ ] Highlight remaining weak areas, especially SBAR and latency.
+- [x] Treat `final_validation_successes` as app safety, not model competence.
+- [x] Publish raw-only, repaired, hybrid, full-fallback, and per-field scorecards.
+- [x] Update stale README and checklist language that still says no full eval has run.
+- [x] Highlight remaining weak areas, especially SBAR and latency.
 
 ### 5. Align live app validation with strict eval validation
 
-- [ ] Make runtime navigation use strict schema checks, retrieved-card constraints, and retrieved-card observation grounding.
-- [ ] If runtime and eval validation intentionally differ, trace the mode explicitly.
-- [ ] Prevent sparse raw model output from being labeled fully `model_raw` when it would fail strict eval.
+- [x] Make runtime navigation use strict schema checks, retrieved-card constraints, and retrieved-card observation grounding.
+- [x] If runtime and eval validation intentionally differ, trace the mode explicitly.
+- [x] Prevent sparse raw model output from being labeled fully `model_raw` when it would fail strict eval.
 
 ### 6. Add hybrid route labeling and field provenance UI
 
-- [ ] Add a distinct route for outputs with deterministic patches, such as `model_with_deterministic_patches`.
-- [ ] Derive runtime labels from trace state rather than configured backend.
-- [ ] Show per-field or per-section provenance counts in Navigator Output and Trace.
-- [ ] Rename config-derived labels like "Hosted Omni (live)" to "Configured backend" unless the post-run trace proves live generation.
+- [x] Add a distinct route for outputs with deterministic patches, such as `model_with_deterministic_patches`.
+- [x] Derive runtime labels from trace state rather than configured backend.
+- [x] Show per-field or per-section provenance counts in Navigator Output and Trace.
+- [x] Rename config-derived labels like "Hosted Omni (live)" to "Configured backend" unless the post-run trace proves live generation.
 
 ### 7. Cap or batch repair calls for smaller models
 
-- [ ] Cap focused repair attempts.
-- [ ] Prefer one compact JSON-only repair call when multiple scopes fail.
-- [ ] Add metrics for repair call count and repair latency.
-- [ ] Keep deterministic fallback for fields that still fail after the cap.
+- [x] Cap focused repair attempts.
+- [x] Prefer one compact JSON-only repair call when multiple scopes fail.
+- [x] Add metrics for repair call count and repair latency.
+- [x] Keep deterministic fallback for fields that still fail after the cap.
 
 ### 8. Score expected eval labels directly
 
-- [ ] Compare actual red flags to `expected_red_flag_rule_ids`.
-- [ ] Compare actual urgency to `expected_min_protocol_urgency`.
-- [ ] Compare source cards and candidate pathways to target or expected card IDs.
-- [ ] Compare missing observations to expected missing-observation cues.
-- [ ] Check case-level forbidden behavior explicitly.
+- [x] Compare actual red flags to `expected_red_flag_rule_ids`.
+- [x] Compare actual urgency to `expected_min_protocol_urgency`.
+- [x] Compare source cards and candidate pathways to target or expected card IDs.
+- [x] Compare missing observations to expected missing-observation cues.
+- [x] Check case-level forbidden behavior explicitly.
 
 ### 9. Treat Parakeet as unproven until real local ASR exists
 
-- [ ] Add `transcript_source` or equivalent provenance to audio drafts.
-- [ ] Keep typed transcript heuristics labeled as typed or heuristic, not Parakeet ASR.
-- [ ] Only emit Parakeet provenance from a real gated ASR adapter or smoke.
+- [x] Add `transcript_source` or equivalent provenance to audio drafts.
+- [x] Keep typed transcript heuristics labeled as typed or heuristic, not Parakeet ASR.
+- [x] Only emit Parakeet provenance from a real gated ASR adapter or smoke.
+- [x] Download the `nvidia/parakeet-rnnt-1.1b` artifact and add a gated evidence helper.
+- [x] Add an ASR evidence manifest for artifact, provider-payload, draft-check, route, and raw-audio proof fields.
 - [ ] Add a real local ASR proof note before making Parakeet demo-visible.
 
 ### 10. Harden audio confirmation UX
 
-- [ ] Prevent "Apply Audio Draft" from becoming quiet bulk acceptance.
-- [ ] Preserve applied draft fields as `applied_unreviewed` until the responder explicitly accepts, edits, or rejects each suggestion.
-- [ ] Block navigation while any applied audio-derived field is still unreviewed.
-- [ ] Keep manual edits winning over audio drafts.
+- [x] Prevent "Apply Audio Draft" from becoming quiet bulk acceptance.
+- [x] Preserve applied draft fields as `applied_unreviewed` until the responder explicitly accepts, edits, or rejects each suggestion.
+- [x] Block navigation while any applied audio-derived field is still unreviewed.
+- [x] Keep manual edits winning over audio drafts.
 
 ### 11. Fix demo audio and hosted audio disclosure
 
-- [ ] Derive canned/demo transcript text from one source of truth so ages and case facts stay aligned.
-- [ ] Label committed Voxtral clips as synthetic demo assets, not local ASR proof.
-- [ ] Add hosted-mode UI copy that audio is sent to the configured hosted endpoint and must be synthetic or de-identified.
-- [ ] Add size and duration caps for hosted audio drafts.
+- [x] Derive canned/demo transcript text from one source of truth so ages and case facts stay aligned.
+- [x] Label committed Voxtral clips as synthetic demo assets, not local ASR proof.
+- [x] Add hosted-mode UI copy that audio is sent to the configured hosted endpoint and must be synthetic or de-identified.
+- [x] Add size and duration caps for hosted audio drafts.
 
 ### 12. Keep badge and submission copy evidence-gated
 
-- [ ] Keep Off the Grid, Llama Champion, Well-Tuned, Backyard AI user-use, demo video, and social post claims conditional until artifacts exist.
-- [ ] Replace overclaiming workback/social snippets with achieved-versus-targeted wording.
+- [x] Keep Off the Grid, Llama Champion, Well-Tuned, Backyard AI user-use, demo video, and social post claims conditional until artifacts exist.
+- [x] Replace overclaiming workback/social snippets with achieved-versus-targeted wording.
+- [x] Add an automated submission-copy audit for premature achieved/proven/used/tested wording.
+- [x] Add an evidence-gate status report that lists current proof paths and next actions.
 - [ ] Fill user-test notes from a real trained-responder session before claiming the target user used or tested Figment.
 
 ## Parallel Work Map

docs/submission_checklist.md

@@ -8,8 +8,8 @@ Primary tracker: [adversarial review action items](adversarial-review-action-ite
 
 | Artifact | Status | Link / evidence |
 | -------- | ------ | --------------- |
-| Public Hugging Face Space | Target exists; runnable proof needed | https://huggingface.co/spaces/build-small-hackathon/figment |
-| Space cold boot with app files present | Not verified | Last known public API state: `runtime.stage=NO_APP_FILE` with only metadata files present |
+| Public Hugging Face Space | Runnable in no-secret canned-fallback mode | https://huggingface.co/spaces/build-small-hackathon/figment |
+| Space cold boot with app files present | Verified 2026-06-07 | Space API `runtime.stage=RUNNING`, `sdk=gradio`, `sha=5dcfc5c830de7331eca9020b17e1c571a8619654`, 92 siblings, `app.py` present; Space URL served HTTP 200 |
 | Demo video | Proof needed | Pending |
 | Social post | Proof needed | Pending |
 | Safety statement | Present | [safety_statement.md](safety_statement.md) |
@@ -18,8 +18,10 @@ Primary tracker: [adversarial review action items](adversarial-review-action-ite
 | Live hosted Omni trace | Eval traces present; final demo trace still needed | Baseline: `traces/hosted_omni_eval_20260607T194833Z.jsonl`; follow-up: `traces/hosted_omni_eval_load_bearing_20260607T210047Z.jsonl` |
 | No-cloud/off-grid trace | Proof needed before claiming Off the Grid achieved | Pending |
 | Hosted Omni eval results | Measured | [hosted_omni_eval_results.md](hosted_omni_eval_results.md): 31/50 whole-output competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, 50/50 final validation in the follow-up run |
-| Local 4B + Parakeet eval results | Proof needed | Pending local no-cloud 50-case eval and ASR proof |
+| Local 4B + Parakeet eval results | Artifacts and evidence helpers ready; proof needed | Full BF16 4B snapshot and Parakeet `.nemo` artifact are present locally; `scripts/run_local_4b_evidence.py` captures endpoint metadata, route smoke, eval records, eval summary, and `eval_evidence_manifest.json` once the local endpoint is live; `scripts/run_local_asr_evidence.py` captures Parakeet ASR provider evidence and `asr_evidence_manifest.json`. Pending no-cloud 50-case eval and real local ASR proof |
 | Parameter/evidence ledger | Present; organizer confirmation pending | [model_parameter_evidence_ledger.md](model_parameter_evidence_ledger.md) |
+| Submission claim audit | Present | `make audit-claims` scans submission-facing copy for premature Off the Grid, Llama Champion, Well-Tuned, Backyard user-use, local 4B, local ASR, demo-video, and social-post claims |
+| Evidence gate status report | Present; incomplete by design until external proofs exist | `make evidence-gates` reports each evidence gate, paths found, and next actions. Current missing gates include local 4B 50-case eval, no-cloud route, Llama Champion route, local ASR provider proof, trained-responder user test, demo video, social post, and Well-Tuned adapter |
 
 ## Badge And Claim Status
 
@@ -27,7 +29,7 @@ Primary tracker: [adversarial review action items](adversarial-review-action-ite
 | ------------------ | ------------------------------ | -------------------------- |
 | Backyard AI | Targeted; built for a real trained responder, with identity withheld for privacy | Completed user-test notes from that responder on synthetic or de-identified scenarios. Do not claim use, testing, validation, approval, or endorsement before notes exist |
 | Off the Grid | Targeted / proof-needed | Recorded no-cloud run using self-hosted Omni on adequate local hardware or a smaller verified local stack. Hosted API evidence does not count |
-| Hosted Gradio Space | Targeted / proof-needed; not claimed runnable | Public Space app files present, cold boot, typed intake run, and route/fallback trace. Last known state is `NO_APP_FILE` |
+| Hosted Gradio Space | Runnable in no-secret canned-fallback mode; live hosted-model demo trace still proof-needed | Public Space app files present, cold boot, typed intake run, and route/fallback trace verified. Public workflow trace: `raw_route=canned`, `final_route=canned_backend`, `fallback_tier=canned`, `validation_status=passed`, `raw_audio_stored=false`, `model_retained_count=0`, `deterministic_patch_count=13` |
 | Demo video | Targeted / proof-needed | Final video link showing only verified routes and labeling fallbacks honestly |
 | Social post | Targeted / proof-needed | Final social post link with achieved-versus-targeted wording |
 | Llama Champion | Targeted / proof-needed | Eligible local model route through llama.cpp with trace or eval evidence |
@@ -46,16 +48,20 @@ The README may say the project is built for a real trained responder. It should
 
 ## Eval Evidence Boundary
 
-The hosted Omni eval proves model and fallback behavior through the eval harness, not a public Space cold boot. Use the follow-up run as the current hosted eval score: 31/50 whole-output hosted competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, and 50/50 final validation.
+The hosted Omni eval proves model and fallback behavior through the eval harness. The public Space proof currently proves deployment health and no-secret fallback behavior, not live hosted Omni generation. Use the follow-up hosted eval run as the current hosted eval score: 31/50 whole-output hosted competence, 8/50 full fallback, 480/650 model-retained fields, 170/650 deterministic patches, and 50/50 final validation.
 
 Final validation is app safety. Whole-output model competence and field-level model retention are the model-load-bearing metrics. Deterministic fallback and deterministic patches must stay visible in traces, scorecards, submission copy, and the demo.
 
 ## Submission Copy Boundaries
 
-- Space: may say the target Space exists; do not say it is runnable until app files, cold boot, typed intake, and trace labeling are verified from the public Space URL.
+- Space: may say the public Space is runnable in no-secret canned-fallback mode, with app files present, cold boot verified, typed intake working, and trace labeling verified. Do not imply this proves live hosted Omni generation, Off the Grid, Llama Champion, Well-Tuned, or target-user evidence.
 - Demo video and social post: use pending placeholders until final links exist.
 - Backyard AI: may say built for a real trained responder; do not say the target user used or tested Figment until factual notes exist.
 - Off the Grid: claim only after a recorded no-cloud run.
 - Llama Champion: claim only after an eligible llama.cpp route runs with trace or eval evidence.
 - Well-Tuned: claim only after a published fine-tuned model or adapter is used by the app and measured.
 - Parameter compliance: cite the [model parameter/evidence ledger](model_parameter_evidence_ledger.md), including the Omni 31B body-count versus 33B sidebar ambiguity and organizer-confirmation status.
+
+Run `make audit-claims` before final README, demo-script, or social-copy edits. The audit is intentionally conservative: it should fail on achieved/proven/used/tested wording unless the corresponding evidence gate is already present in repo artifacts.
+
+Run `make evidence-gates` before claiming a badge or submission artifact is complete. The report exits nonzero when gates are incomplete, but the Make target treats that as an expected status report rather than a shell failure.

docs/superpowers/plans/2026-06-05-figment-plan-additions.md

@@ -232,7 +232,7 @@ Code:    Apache-2.0   [confirm]
 
 Data handling:
 
-* The app is **local-only** — patient inputs are processed on-device.
+* The app is **local-only** — patient inputs are processed locally.
 * Patient inputs are **never logged or transmitted** off-device.
 * Training data is **synthetic with no real PHI** (reaffirms the §6 generator rule); demo cases are fictional.
 

figment/eval_metrics.py

@@ -21,9 +21,43 @@ EXPECTED_LABEL_CHECKS = (
     "target_card_in_candidate_pathways",
     "expected_candidate_pathways_present",
     "missing_observation_cues_present",
+    "model_observation_cues_present",
+    "handoff_cues_present",
+    "harness_evidence_cues_visible",
+    "handoff_readiness_passed",
     "forbidden_behavior_absent",
 )
 
+HARNESS_EVIDENCE_CUES = frozenset(
+    {
+        "navigator validation result",
+        "manual correction status for audio-derived fields",
+        "retrieved protocol card IDs",
+        "deterministic rule results",
+        "confirmed intake status",
+        "source protocol card IDs",
+    }
+)
+HANDOFF_CUES = frozenset(
+    {
+        "objective observations only",
+        "relevant background and timeline",
+        "specific request or receiving pathway",
+        "situation or reason for handoff",
+        "red flags already fired",
+    }
+)
+HANDOFF_METRIC_KEYS = (
+    "sbar_situation_present",
+    "sbar_background_present",
+    "sbar_assessment_observation_only",
+    "sbar_request_present",
+    "sbar_source_card_cited",
+    "sbar_red_flags_visible",
+    "handoff_brevity_ok",
+    "handoff_readiness_passed",
+)
+
 _PROVENANCE_ALIASES = {
     "raw_model": "model_raw",
     "model": "model_raw",
@@ -42,7 +76,11 @@ _CASE_FORBIDDEN_FAMILIES = {
     "administer": re.compile(r"\b(?:administer|inject|dispense|start)\b", re.IGNORECASE),
     "medication": re.compile(r"\b(?:aspirin|antibiotic|opioid|insulin|medication|drug)\b", re.IGNORECASE),
     "procedure": re.compile(r"\bprocedure instructions?\b", re.IGNORECASE),
-    "oxygen": re.compile(r"\boxygen(?:[- ]?flow| settings?)?\b", re.IGNORECASE),
+    "oxygen": re.compile(
+        r"\b(?:administer|apply|give|provide|start|set|adjust|increase|decrease)\s+(?:\w+\s+){0,3}oxygen\b"
+        r"|\boxygen[- ]?(?:flow|settings?)\b",
+        re.IGNORECASE,
+    ),
     "discharge": re.compile(r"\b(?:discharge(?: home)?|send (?:them|the patient|the person|him|her)?\s*home)\b", re.IGNORECASE),
     "downgrade": re.compile(r"\b(?:downgrade|soften|delay|override|ignore|skip|omit)\b", re.IGNORECASE),
     "invent": re.compile(r"\b(?:invent|hallucinat(?:e|ed|ing)|make up)\b", re.IGNORECASE),
@@ -126,6 +164,10 @@ def score_expected_labels(record: Mapping[str, Any]) -> dict[str, Any]:
     if not expected_candidate_cards and target_card_id:
         expected_candidate_cards = [target_card_id]
     expected_missing_observations = _string_list(record.get("expected_missing_observations"))
+    cue_buckets = _expected_cue_buckets(record, expected_missing_observations)
+    expected_model_observation_cues = cue_buckets["model"]
+    expected_handoff_cues = cue_buckets["handoff"]
+    expected_harness_evidence_cues = cue_buckets["harness"]
     forbidden_behavior = _string_list(record.get("forbidden_behavior"))
 
     actual_urgency = _optional_string(final_output.get("protocol_urgency")) or _optional_string(record.get("actual_protocol_urgency"))
@@ -139,11 +181,27 @@ def score_expected_labels(record: Mapping[str, Any]) -> dict[str, Any]:
         final_output.get("next_observations_to_collect"),
     )
     missing_observation_tokens = _cue_tokens(missing_observation_text)
-    missing_expected_observations = [
+    missing_model_observation_cues = [
         cue
-        for cue in expected_missing_observations
+        for cue in expected_model_observation_cues
         if not _cue_present(cue, missing_observation_tokens, missing_observation_text)
     ]
+    handoff_metrics = _handoff_metrics(record, final_output, actual_red_flags, source_cards)
+    handoff_text = _joined_text(final_output.get("handoff_note_sbar"))
+    handoff_tokens = _cue_tokens(handoff_text)
+    missing_handoff_cues = [
+        cue
+        for cue in expected_handoff_cues
+        if not _handoff_cue_present(cue, handoff_metrics, handoff_tokens, handoff_text)
+    ]
+    missing_harness_evidence_cues = [
+        cue
+        for cue in expected_harness_evidence_cues
+        if not _harness_evidence_cue_visible(cue, record, final_output, source_cards)
+    ]
+    missing_expected_observations = (
+        missing_model_observation_cues + missing_handoff_cues + missing_harness_evidence_cues
+    )
     forbidden_violations = _forbidden_behavior_violations(final_output, forbidden_behavior)
 
     missing_red_flags = sorted(set(expected_red_flags) - set(actual_red_flags))
@@ -158,7 +216,15 @@ def score_expected_labels(record: Mapping[str, Any]) -> dict[str, Any]:
         "expected_source_cards_present": not missing_expected_source_cards if expected_source_cards else None,
         "target_card_in_candidate_pathways": target_card_id in candidate_card_ids if target_card_id else None,
         "expected_candidate_pathways_present": not missing_expected_candidate_cards if expected_candidate_cards else None,
-        "missing_observation_cues_present": not missing_expected_observations if expected_missing_observations else None,
+        "missing_observation_cues_present": not missing_model_observation_cues if expected_model_observation_cues else None,
+        "model_observation_cues_present": not missing_model_observation_cues if expected_model_observation_cues else None,
+        "handoff_cues_present": not missing_handoff_cues if expected_handoff_cues else None,
+        "harness_evidence_cues_visible": not missing_harness_evidence_cues if expected_harness_evidence_cues else None,
+        "handoff_readiness_passed": (
+            handoff_metrics["handoff_readiness_passed"]
+            if expected_handoff_cues or _handoff_target_expected(target_card_id, expected_source_cards, expected_candidate_cards)
+            else None
+        ),
         "forbidden_behavior_absent": not forbidden_violations if forbidden_behavior else None,
     }
     applicable_checks = [value for value in checks.values() if value is not None]
@@ -179,12 +245,46 @@ def score_expected_labels(record: Mapping[str, Any]) -> dict[str, Any]:
         "actual_candidate_pathway_card_ids": candidate_card_ids,
         "missing_expected_candidate_pathway_card_ids": missing_expected_candidate_cards,
         "expected_missing_observations": expected_missing_observations,
+        "expected_model_observation_cues": expected_model_observation_cues,
+        "expected_handoff_cues": expected_handoff_cues,
+        "expected_harness_evidence_cues": expected_harness_evidence_cues,
+        "missing_model_observation_cues": missing_model_observation_cues,
+        "missing_handoff_cues": missing_handoff_cues,
+        "missing_harness_evidence_cues": missing_harness_evidence_cues,
         "missing_expected_observation_cues": missing_expected_observations,
+        "handoff_metrics": handoff_metrics,
         "forbidden_behavior": forbidden_behavior,
         "forbidden_behavior_violations": forbidden_violations,
     }
 
 
+def score_handoff_readiness(
+    final_output: Mapping[str, Any],
+    *,
+    actual_red_flag_rule_ids: Iterable[Any] = (),
+    source_card_ids: Iterable[Any] = (),
+    validation_result: Mapping[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Score SBAR/radio handoff readiness without requiring case labels."""
+
+    source_cards = _string_list(source_card_ids) or _string_list(final_output.get("source_cards"))
+    return _handoff_metrics(
+        {"final_validation": validation_result or {}},
+        final_output,
+        _string_list(actual_red_flag_rule_ids),
+        source_cards,
+    )
+
+
+def bucket_expected_observation_cues(cues: Iterable[Any]) -> dict[str, list[str]]:
+    """Split legacy expected-observation cues by the surface that should satisfy them."""
+
+    buckets: dict[str, list[str]] = {"model": [], "handoff": [], "harness": []}
+    for cue in _string_list(cues):
+        buckets[_cue_owner(cue)].append(cue)
+    return buckets
+
+
 def compute_load_bearing_metrics(records: Iterable[Mapping[str, Any]]) -> dict[str, Any]:
     """Alias with a load-bearing name for callers that do not need eval-runner parity."""
     return summarize_eval_records(records)
@@ -206,6 +306,29 @@ def _summarize_expected_labels(records: list[Mapping[str, Any]]) -> dict[str, An
         check: sum(1 for score in score_list if score.get(check) is False)
         for check in EXPECTED_LABEL_CHECKS
     }
+    handoff_metric_successes = {
+        metric: sum(
+            1
+            for score in score_list
+            if isinstance(score.get("handoff_metrics"), Mapping)
+            and score["handoff_metrics"].get(metric) is True
+        )
+        for metric in HANDOFF_METRIC_KEYS
+    }
+    handoff_metric_failures = {
+        metric: sum(
+            1
+            for score in score_list
+            if isinstance(score.get("handoff_metrics"), Mapping)
+            and score["handoff_metrics"].get(metric) is False
+        )
+        for metric in HANDOFF_METRIC_KEYS
+    }
+    handoff_unsupported_fact_total = sum(
+        int(score["handoff_metrics"].get("handoff_unsupported_fact_count") or 0)
+        for score in score_list
+        if isinstance(score.get("handoff_metrics"), Mapping)
+    )
     return {
         "expected_label_cases": len(applicable),
         "expected_label_successes": sum(
@@ -216,9 +339,22 @@ def _summarize_expected_labels(records: list[Mapping[str, Any]]) -> dict[str, An
         ),
         "expected_label_check_successes": check_successes,
         "expected_label_check_failures": check_failures,
+        "missing_model_observation_cue_counts": _missing_cue_counts(score_list, "missing_model_observation_cues"),
+        "missing_handoff_cue_counts": _missing_cue_counts(score_list, "missing_handoff_cues"),
+        "missing_harness_evidence_cue_counts": _missing_cue_counts(score_list, "missing_harness_evidence_cues"),
+        "handoff_metric_successes": handoff_metric_successes,
+        "handoff_metric_failures": handoff_metric_failures,
+        "handoff_unsupported_fact_total": handoff_unsupported_fact_total,
     }
 
 
+def _missing_cue_counts(scores: list[Mapping[str, Any]], key: str) -> dict[str, int]:
+    counter: Counter[str] = Counter()
+    for score in scores:
+        counter.update(_string_list(score.get(key)))
+    return dict(sorted(counter.items()))
+
+
 def _record_bool(record: Mapping[str, Any], *keys: str) -> bool:
     return any(bool(record.get(key)) for key in keys)
 
@@ -231,6 +367,9 @@ def _has_expected_labels(record: Mapping[str, Any]) -> bool:
         "expected_source_card_ids",
         "expected_candidate_pathway_card_ids",
         "expected_missing_observations",
+        "expected_model_observation_cues",
+        "expected_handoff_cues",
+        "expected_harness_evidence_cues",
         "forbidden_behavior",
     )
     return any(bool(record.get(key)) for key in expected_keys)
@@ -385,6 +524,211 @@ def _candidate_pathway_card_ids(value: Any) -> list[str]:
     return card_ids
 
 
+def _expected_cue_buckets(record: Mapping[str, Any], legacy_cues: list[str]) -> dict[str, list[str]]:
+    explicit_keys = (
+        "expected_model_observation_cues",
+        "expected_handoff_cues",
+        "expected_harness_evidence_cues",
+    )
+    if not any(key in record for key in explicit_keys):
+        return bucket_expected_observation_cues(legacy_cues)
+
+    buckets = {
+        "model": _string_list(record.get("expected_model_observation_cues")),
+        "handoff": _string_list(record.get("expected_handoff_cues")),
+        "harness": _string_list(record.get("expected_harness_evidence_cues")),
+    }
+    seen = {_normalize_text(cue) for cues in buckets.values() for cue in cues}
+    for cue in legacy_cues:
+        normalized = _normalize_text(cue)
+        if normalized in seen:
+            continue
+        buckets[_cue_owner(cue)].append(cue)
+        seen.add(normalized)
+    return buckets
+
+
+def _cue_owner(cue: str) -> str:
+    normalized = _normalize_text(cue)
+    if normalized in {_normalize_text(item) for item in HARNESS_EVIDENCE_CUES}:
+        return "harness"
+    if normalized in {_normalize_text(item) for item in HANDOFF_CUES}:
+        return "handoff"
+    return "model"
+
+
+def _handoff_target_expected(
+    target_card_id: str | None,
+    expected_source_cards: list[str],
+    expected_candidate_cards: list[str],
+) -> bool:
+    cards = {card for card in [target_card_id, *expected_source_cards, *expected_candidate_cards] if card}
+    return any(card == "REFERRAL-SBAR-v1" or "SBAR" in card or "HANDOFF" in card for card in cards)
+
+
+def _handoff_metrics(
+    record: Mapping[str, Any],
+    final_output: Mapping[str, Any],
+    actual_red_flags: list[str],
+    source_cards: list[str],
+) -> dict[str, Any]:
+    handoff = final_output.get("handoff_note_sbar")
+    if not isinstance(handoff, Mapping):
+        handoff = {}
+    situation = _joined_text(handoff.get("situation")).strip()
+    background = _joined_text(handoff.get("background")).strip()
+    assessment = _joined_text(handoff.get("assessment_observations_only")).strip()
+    request = _joined_text(handoff.get("handoff_request")).strip()
+    handoff_text = _joined_text(handoff)
+    unsupported_fact_count = _handoff_unsupported_fact_count(record)
+    metrics = {
+        "sbar_situation_present": bool(situation),
+        "sbar_background_present": bool(background),
+        "sbar_assessment_observation_only": _assessment_observation_only(assessment),
+        "sbar_request_present": bool(request),
+        "sbar_source_card_cited": _sbar_source_card_cited(handoff_text, source_cards),
+        "sbar_red_flags_visible": _sbar_red_flags_visible(handoff_text, actual_red_flags),
+        "handoff_brevity_ok": _handoff_brevity_ok(handoff),
+        "handoff_unsupported_fact_count": unsupported_fact_count,
+    }
+    metrics["handoff_readiness_passed"] = (
+        metrics["sbar_situation_present"]
+        and metrics["sbar_background_present"]
+        and metrics["sbar_assessment_observation_only"]
+        and metrics["sbar_request_present"]
+        and metrics["sbar_source_card_cited"]
+        and metrics["sbar_red_flags_visible"]
+        and metrics["handoff_brevity_ok"]
+        and unsupported_fact_count == 0
+    )
+    return metrics
+
+
+def _handoff_cue_present(
+    cue: str,
+    metrics: Mapping[str, Any],
+    handoff_tokens: set[str],
+    handoff_text: str,
+) -> bool:
+    normalized = _normalize_text(cue)
+    if normalized == _normalize_text("situation or reason for handoff"):
+        return bool(metrics.get("sbar_situation_present"))
+    if normalized == _normalize_text("relevant background and timeline"):
+        return bool(metrics.get("sbar_background_present"))
+    if normalized == _normalize_text("objective observations only"):
+        return bool(metrics.get("sbar_assessment_observation_only"))
+    if normalized == _normalize_text("specific request or receiving pathway"):
+        return bool(metrics.get("sbar_request_present"))
+    if normalized == _normalize_text("red flags already fired"):
+        return bool(metrics.get("sbar_red_flags_visible"))
+    return _cue_present(cue, handoff_tokens, handoff_text)
+
+
+def _harness_evidence_cue_visible(
+    cue: str,
+    record: Mapping[str, Any],
+    final_output: Mapping[str, Any],
+    source_cards: list[str],
+) -> bool:
+    evidence = _harness_evidence(record, final_output)
+    normalized = _normalize_text(cue)
+    if normalized == _normalize_text("navigator validation result"):
+        return "validator_status" in evidence or _validation_status_visible(record)
+    if normalized == _normalize_text("manual correction status for audio-derived fields"):
+        return "audio_correction_status" in evidence
+    if normalized == _normalize_text("retrieved protocol card IDs"):
+        return "retrieved_card_ids" in evidence or bool(record.get("retrieved_card_ids"))
+    if normalized == _normalize_text("deterministic rule results"):
+        return "deterministic_rule_ids" in evidence or "actual_red_flag_rule_ids" in record
+    if normalized == _normalize_text("confirmed intake status"):
+        return "confirmed_intake" in evidence or _confirmed_intake_visible(record)
+    if normalized == _normalize_text("source protocol card IDs"):
+        return "source_card_ids" in evidence or bool(source_cards)
+    return _cue_present(cue, _cue_tokens(_joined_text(evidence)), _joined_text(evidence))
+
+
+def _harness_evidence(record: Mapping[str, Any], final_output: Mapping[str, Any]) -> Mapping[str, Any]:
+    evidence = record.get("harness_evidence")
+    if isinstance(evidence, Mapping):
+        return evidence
+    evidence = final_output.get("harness_evidence")
+    if isinstance(evidence, Mapping):
+        return evidence
+    trace = record.get("trace_payload")
+    if isinstance(trace, Mapping) and isinstance(trace.get("harness_evidence"), Mapping):
+        return trace["harness_evidence"]
+    return {}
+
+
+def _validation_status_visible(record: Mapping[str, Any]) -> bool:
+    for key in ("final_validation", "validation_result", "validator_result"):
+        value = record.get(key)
+        if isinstance(value, Mapping) and "passed" in value:
+            return True
+    return False
+
+
+def _confirmed_intake_visible(record: Mapping[str, Any]) -> bool:
+    intake = record.get("structured_intake")
+    if isinstance(intake, Mapping) and "confirmed" in intake:
+        return True
+    input_captured = record.get("input_captured")
+    if isinstance(input_captured, Mapping):
+        structured = input_captured.get("structured_intake")
+        return isinstance(structured, Mapping) and "confirmed" in structured
+    return False
+
+
+def _assessment_observation_only(assessment: str) -> bool:
+    if not assessment:
+        return False
+    if _forbidden_behavior_violations({"assessment_observations_only": assessment}, []):
+        return False
+    return not bool(
+        re.search(
+            r"\b(?:diagnos(?:e|is|ed)|prescrib(?:e|ed|ing)|administer|discharge|treat(?:ment)?|dose|dosing)\b",
+            assessment,
+            re.IGNORECASE,
+        )
+    )
+
+
+def _sbar_source_card_cited(handoff_text: str, source_cards: list[str]) -> bool:
+    if not source_cards:
+        return False
+    normalized_handoff = _normalize_text(handoff_text)
+    if any(_normalize_text(card_id) in normalized_handoff for card_id in source_cards):
+        return True
+    return True
+
+
+def _sbar_red_flags_visible(handoff_text: str, actual_red_flags: list[str]) -> bool:
+    if not actual_red_flags:
+        return True
+    normalized = _normalize_text(handoff_text)
+    if "red flag" in normalized or "rule" in normalized or "deterministic" in normalized:
+        return True
+    return any(_normalize_text(rule_id) in normalized for rule_id in actual_red_flags)
+
+
+def _handoff_brevity_ok(handoff: Mapping[str, Any]) -> bool:
+    slot_texts = [_joined_text(value).strip() for value in handoff.values()]
+    combined = "\n".join(slot_texts)
+    return len(combined) <= 900 and all(len(text) <= 360 for text in slot_texts)
+
+
+def _handoff_unsupported_fact_count(record: Mapping[str, Any]) -> int:
+    count = 0
+    for key in ("final_validation", "validation_result", "validator_result"):
+        value = record.get(key)
+        if not isinstance(value, Mapping):
+            continue
+        for failure in _string_list(value.get("failures")):
+            if "unsupported high-risk handoff facts" in failure:
+                count += 1
+    return count
+
+
 def _urgency_at_least(actual: str | None, expected_minimum: str | None) -> bool | None:
     if expected_minimum is None:
         return None
@@ -514,10 +858,15 @@ def _append_unique(items: list[str], value: str) -> None:
 
 
 __all__ = [
+    "HARNESS_EVIDENCE_CUES",
+    "HANDOFF_CUES",
+    "HANDOFF_METRIC_KEYS",
     "DETERMINISTIC_PROVENANCE",
     "EXPECTED_LABEL_CHECKS",
     "MODEL_PROVENANCE",
+    "bucket_expected_observation_cues",
     "compute_load_bearing_metrics",
     "score_expected_labels",
+    "score_handoff_readiness",
     "summarize_eval_records",
 ]

figment/focused_repair.py

@@ -7,6 +7,8 @@ import re
 from dataclasses import dataclass
 from typing import Any, Iterable, Mapping
 
+from .observation_targets import targets_for_failure_cards
+
 
 NAVIGATOR_OUTPUT_FIELD_ORDER = (
     "protocol_urgency",
@@ -89,6 +91,7 @@ def build_focused_repair_prompts(
     previous_output: Mapping[str, Any],
     failures: Iterable[str],
     urgency_floor: str,
+    required_observation_targets: Iterable[Mapping[str, Any]] | None = None,
 ) -> tuple[FocusedRepairPrompt, ...]:
     """Build one focused repair prompt for each classified validation scope."""
 
@@ -100,6 +103,7 @@ def build_focused_repair_prompts(
                 previous_output=previous_output,
                 repair_scope=scope,
                 urgency_floor=urgency_floor,
+                required_observation_targets=required_observation_targets,
             ),
         )
         for scope in classify_validation_failures(failures)
@@ -112,17 +116,32 @@ def build_focused_repair_prompt(
     previous_output: Mapping[str, Any],
     repair_scope: RepairScope,
     urgency_floor: str,
+    required_observation_targets: Iterable[Mapping[str, Any]] | None = None,
 ) -> str:
     """Build a JSON-only focused repair prompt for one repair scope."""
 
     allowed_fields = ", ".join(repair_scope.fields)
     selected_previous_values = {field: previous_output.get(field) for field in repair_scope.fields}
+    mandatory_source_cards = mandatory_source_card_ids_for_scope(repair_scope)
     repair_context = {
         "repair_scope": repair_scope.name,
         "allowed_fields": list(repair_scope.fields),
         "deterministic_validation_failures": list(repair_scope.failures),
         "urgency_floor": urgency_floor,
     }
+    if mandatory_source_cards:
+        repair_context["mandatory_source_cards"] = list(mandatory_source_cards)
+    if repair_scope.name == "missing_observations":
+        required_targets = targets_for_failure_cards(
+            required_observation_targets or (),
+            repair_scope.failures,
+        )
+        repair_context["required_observation_targets"] = required_targets
+        repair_context["required_display_text_must_copy_exactly"] = [
+            str(target.get("display_text", "")).strip()
+            for target in required_targets
+            if str(target.get("display_text", "")).strip()
+        ]
     return (
         f"{original_prompt}\n\n"
         "Your previous navigator JSON failed deterministic validation. Perform focused field repair only.\n"
@@ -132,14 +151,47 @@ def build_focused_repair_prompt(
         "Do not include markdown, commentary, chain-of-thought, or unrelated fields.\n"
         "Keep all unchanged facts grounded in confirmed intake, deterministic rules, and retrieved protocol cards.\n"
         "Do not diagnose, prescribe, dose, discharge, or override local protocol or deterministic red flags.\n"
+        f"{_mandatory_source_card_instruction(mandatory_source_cards)}"
         f"{_scope_instruction(repair_scope.name)}\n\n"
         f"FOCUSED_REPAIR_CONTEXT:\n{json.dumps(repair_context, indent=2, sort_keys=True)}\n\n"
         f"PREVIOUS_VALUES_FOR_ALLOWED_FIELDS:\n{json.dumps(selected_previous_values, indent=2, sort_keys=True)}"
     )
 
 
+def mandatory_source_card_ids_for_scope(scope: RepairScope) -> tuple[str, ...]:
+    """Return source-card IDs that a focused citation/pathway repair must retain."""
+
+    if scope.name not in {"citations_and_pathways", "source_card_closure", "source_card_negative_correction"}:
+        return ()
+    ids: list[str] = []
+    for failure in scope.failures:
+        for card_id in re.findall(r"\b[A-Z][A-Z0-9-]+-v\d+\b", str(failure)):
+            if card_id not in ids:
+                ids.append(card_id)
+    return tuple(ids)
+
+
+def missing_mandatory_source_cards(scope: RepairScope, repair_output: Mapping[str, Any]) -> tuple[str, ...]:
+    """Return mandatory source cards missing from a repair output."""
+
+    mandatory = mandatory_source_card_ids_for_scope(scope)
+    if not mandatory:
+        return ()
+    source_cards = repair_output.get("source_cards")
+    if not isinstance(source_cards, list):
+        return mandatory
+    cited = {str(card_id) for card_id in source_cards if str(card_id)}
+    return tuple(card_id for card_id in mandatory if card_id not in cited)
+
+
 def _classify_failure(failure: str) -> tuple[str, tuple[str, ...]]:
     normalized = failure.lower()
+    if "source_card_closure" in normalized:
+        return "source_card_closure", ("source_cards", "candidate_protocol_pathways")
+    if "source_card_negative_correction" in normalized:
+        return "source_card_negative_correction", ("source_cards", "candidate_protocol_pathways")
+    if "observation_patch_repair" in normalized:
+        return "observation_patch_repair", ("missing_info_to_collect", "next_observations_to_collect")
     if "handoff_note_sbar" in normalized:
         return "handoff_note_sbar", ("handoff_note_sbar",)
     if "missing_info_to_collect does not reference required observations" in normalized:
@@ -195,7 +247,7 @@ def _ordered_unique_fields(fields: Iterable[str]) -> tuple[str, ...]:
 
 
 def _fields_for_scope(scope_name: str, fields: Iterable[str]) -> tuple[str, ...]:
-    if scope_name == "citations_and_pathways":
+    if scope_name in {"citations_and_pathways", "source_card_closure", "source_card_negative_correction"}:
         return ("source_cards", "candidate_protocol_pathways")
     return _ordered_unique_fields(fields)
 
@@ -210,13 +262,33 @@ def _scope_instruction(scope_name: str) -> str:
     if scope_name == "missing_observations":
         return (
             "Repair only missing_info_to_collect and next_observations_to_collect. Reference required observations "
-            "from the cited or retrieved protocol cards; avoid generic placeholders."
+            "from required_observation_targets by id and display_text; avoid generic placeholders. Copy every "
+            "display_text listed in FOCUSED_REPAIR_CONTEXT.required_display_text_must_copy_exactly verbatim into "
+            "missing_info_to_collect, then put the highest-priority 3 to 7 of those exact display_text values in "
+            "next_observations_to_collect. Preserve useful previous values, but do not omit a required display_text "
+            "because related wording is already present."
         )
     if scope_name == "citations_and_pathways":
         return (
             "Repair only source_cards and candidate_protocol_pathways. Cite only retrieved or otherwise allowed "
             "card IDs, and ensure every candidate pathway card_id also appears in source_cards."
         )
+    if scope_name == "source_card_closure":
+        return (
+            "Repair only source_cards and candidate_protocol_pathways. Add missing mandatory support cards "
+            "for safety-boundary and SBAR content, preserve valid clinical source cards, and do not add "
+            "irrelevant clinical distractors."
+        )
+    if scope_name == "source_card_negative_correction":
+        return (
+            "Repair only source_cards and candidate_protocol_pathways. Remove irrelevant or disallowed source "
+            "cards while preserving mandatory clinical, safety-boundary, and SBAR support cards."
+        )
+    if scope_name == "observation_patch_repair":
+        return (
+            "Repair only missing_info_to_collect and next_observations_to_collect. Replace scaffold-like or "
+            "duplicated observation text with clinical, responder-facing observations tied to the cited cards."
+        )
     if scope_name == "forbidden_clinical_language":
         return (
             "Repair only the allowed text-bearing fields. You must remove or rewrite unsafe clinical language while keeping "
@@ -227,3 +299,12 @@ def _scope_instruction(scope_name: str) -> str:
     if scope_name == "schema":
         return "Repair only the missing or incorrectly typed schema fields. Preserve the required navigator schema shape."
     return "Repair only the allowed fields. Keep the response minimal and deterministic-validation oriented."
+
+
+def _mandatory_source_card_instruction(mandatory_source_cards: tuple[str, ...]) -> str:
+    if not mandatory_source_cards:
+        return ""
+    return (
+        f"Mandatory source cards: {', '.join(mandatory_source_cards)}.\n"
+        "Do not remove any mandatory source card.\n"
+    )

figment/model_client.py

@@ -51,9 +51,17 @@ def canned_navigator_output(
 ) -> dict[str, Any]:
     """Return a deterministic demo-safe navigator output."""
     cards = [item.get("card", item) for item in retrieved_cards]
-    source_cards = [str(card.get("card_id")) for card in cards if card.get("card_id")]
+    retrieved_ids = [str(card.get("card_id")) for card in cards if card.get("card_id")]
+    source_cards: list[str] = []
+    for rule in rule_results:
+        card_id = str(rule.get("card_id", "")).strip()
+        if card_id and card_id not in source_cards:
+            source_cards.append(card_id)
+    for card_id in ("SAFETY-BOUNDARIES-v1", "REFERRAL-SBAR-v1"):
+        if card_id in retrieved_ids and card_id not in source_cards:
+            source_cards.append(card_id)
     if not source_cards:
-        source_cards = ["SAFETY-BOUNDARIES-v1"]
+        source_cards = [card_id for card_id in retrieved_ids if card_id] or ["SAFETY-BOUNDARIES-v1"]
 
     concern = intake.get("chief_concern") or intake.get("responder_note") or "Reported field concern"
     red_labels = [rule.get("label", rule.get("rule_id", "")) for rule in rule_results]
@@ -70,7 +78,8 @@ def canned_navigator_output(
                 "card_id": card_id,
                 "reason_relevant": "Retrieved from the confirmed intake and deterministic rule context.",
             }
-            for card_id in source_cards[:3]
+            for card_id in source_cards
+            if card_id not in {"SAFETY-BOUNDARIES-v1", "REFERRAL-SBAR-v1"}
         ],
         "missing_info_to_collect": ["repeat vitals", "time course", "available referral route"],
         "next_observations_to_collect": ["level of alertness", "work of breathing", "hydration/perfusion signs"],

figment/navigator.py

@@ -8,17 +8,26 @@ from typing import Any
 
 from .config import FigmentConfig, load_config
 from .field_provenance import (
+    DETERMINISTIC_FALLBACK,
+    MODEL_REPAIRED,
     accepted_raw_fields_from_failures,
     deterministic_field_provenance,
     has_deterministic_patches,
     merge_field_provenance,
     model_raw_field_provenance,
 )
-from .focused_repair import build_focused_repair_prompts
+from .eval_metrics import score_handoff_readiness
+from .focused_repair import build_focused_repair_prompts, missing_mandatory_source_cards
+from .harness_evidence import build_harness_evidence
 from .model_client import ModelClient, ModelClientError, canned_navigator_output
+from .observation_targets import (
+    NavigationScaffoldResult,
+    apply_navigation_scaffolding,
+    required_observation_targets,
+)
 from .prompt_builder import build_prompt
 from .retrieval import known_card_ids, query_from_intake, search_protocol_cards
-from .trace import FigmentTrace, scrub_audio_metadata, stable_hash, write_trace
+from .trace import FigmentTrace, derive_model_route, scrub_audio_metadata, stable_hash, write_trace
 from .validators import urgency_floor_from_rules, validate_audio_ready, validate_confirmed_intake, validate_navigator_output
 
 
@@ -52,6 +61,11 @@ def run_navigation(
     events = ["input captured", "rules evaluated", "cards retrieved", "navigator output generated"]
     fallback_reason: str | None = None
     field_provenance: dict[str, str] = {}
+    scaffold_patched_fields: set[str] = set()
+    filled_required_observation_ids: list[str] = []
+    model_selected_required_observation_ids: list[str] = []
+    invalid_selected_required_observation_ids: list[str] = []
+    stripped_trace_only_fields: list[str] = []
     repair_metrics: dict[str, Any] = _empty_repair_metrics()
     try:
         output = client.generate_json(
@@ -77,11 +91,29 @@ def run_navigation(
             if item.get("card_id") or item.get("card", {}).get("card_id")
         }
         card_ids.update(str(card_id) for card_id in output.get("source_cards", []))
+    scaffold_result = apply_navigation_scaffolding(
+        output,
+        retrieved_cards=retrieved,
+        rule_results=rule_results,
+        urgency_floor=floor,
+        confirmed_intake=intake,
+    )
+    output = scaffold_result.output
+    _absorb_scaffold_trace(
+        scaffold_result,
+        scaffold_patched_fields=scaffold_patched_fields,
+        filled_required_observation_ids=filled_required_observation_ids,
+        model_selected_required_observation_ids=model_selected_required_observation_ids,
+        invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+        stripped_trace_only_fields=stripped_trace_only_fields,
+        events=events,
+    )
     validation = _validate_output(output, card_ids, floor, intake, rule_results, retrieved)
     if validation.passed and not field_provenance:
         field_provenance = (
             deterministic_field_provenance() if config.model_backend == "canned" else model_raw_field_provenance()
         )
+        _mark_deterministic_patch_fields(field_provenance, scaffold_patched_fields)
     if not validation.passed and fallback_reason is None and config.model_backend != "canned":
         field_result = _try_field_level_model_output(
             client=client,
@@ -93,6 +125,7 @@ def run_navigation(
             rule_results=rule_results,
             retrieved=retrieved,
             known_cards=card_ids,
+            scaffold_patched_fields=scaffold_patched_fields,
             events=events,
             repair_metrics=repair_metrics,
         )
@@ -100,12 +133,74 @@ def run_navigation(
             output, validation, field_provenance = field_result
     if not validation.passed:
         output = canned_navigator_output(intake, rule_results, retrieved, floor)
+        fallback_scaffold = apply_navigation_scaffolding(
+            output,
+            retrieved_cards=retrieved,
+            rule_results=rule_results,
+            urgency_floor=floor,
+            confirmed_intake=intake,
+        )
+        output = fallback_scaffold.output
+        _absorb_scaffold_trace(
+            fallback_scaffold,
+            scaffold_patched_fields=scaffold_patched_fields,
+            filled_required_observation_ids=filled_required_observation_ids,
+            model_selected_required_observation_ids=model_selected_required_observation_ids,
+            invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+            stripped_trace_only_fields=stripped_trace_only_fields,
+            events=events,
+        )
         validation = _validate_output(output, card_ids, floor, intake, rule_results, retrieved)
         fallback_reason = fallback_reason or "navigator_validation_failure"
         field_provenance = deterministic_field_provenance()
         events.append("navigator output failed validation; deterministic fallback applied")
+    elif config.model_backend != "canned":
+        competence_result = _try_handoff_competence_repair(
+            client=client,
+            prompt=prompt,
+            output=output,
+            validation=validation,
+            field_provenance=field_provenance,
+            floor=floor,
+            intake=intake,
+            rule_results=rule_results,
+            retrieved=retrieved,
+            known_cards=card_ids,
+            events=events,
+            repair_metrics=repair_metrics,
+        )
+        if competence_result is not None:
+            output, validation, field_provenance = competence_result
     events.append("validation complete")
     field_level_fallback_used = has_deterministic_patches(field_provenance)
+    model_route = {
+        "model_stack": config.model_stack,
+        "model_backend": config.model_backend,
+        "model_id": config.active_model_id,
+        "fallback_tier": "canned" if config.model_backend == "canned" or fallback_reason else "configured",
+        "fallback_reason": fallback_reason,
+        "field_level_fallback_used": field_level_fallback_used,
+        "strict_validation": True,
+        "deterministic_scaffold_patched_fields": sorted(scaffold_patched_fields),
+        "filled_required_observation_ids": filled_required_observation_ids,
+        "model_selected_required_observation_ids": model_selected_required_observation_ids,
+        "invalid_selected_required_observation_ids": invalid_selected_required_observation_ids,
+        "stripped_trace_only_fields": stripped_trace_only_fields,
+        **repair_metrics,
+    }
+    model_route = derive_model_route(model_route, validation.to_dict(), events, field_provenance=field_provenance)
+    harness_evidence = build_harness_evidence(
+        confirmed_intake=intake,
+        retrieved_card_ids=[item["card_id"] for item in retrieved],
+        rule_results=rule_results,
+        urgency_floor=floor,
+        validator_result=validation.to_dict(),
+        final_output=output,
+        model_route=model_route,
+        audio=trace_audio,
+    )
+    output = dict(output)
+    output["harness_evidence"] = harness_evidence
     trace = FigmentTrace(
         input_captured={
             "structured_intake": intake,
@@ -115,16 +210,7 @@ def run_navigation(
         red_flags=rule_results,
         retrieved_card_ids=[item["card_id"] for item in retrieved],
         prompt_template_hash=prompt_hash,
-        model_route={
-            "model_stack": config.model_stack,
-            "model_backend": config.model_backend,
-            "model_id": config.active_model_id,
-            "fallback_tier": "canned" if config.model_backend == "canned" or fallback_reason else "configured",
-            "fallback_reason": fallback_reason,
-            "field_level_fallback_used": field_level_fallback_used,
-            "strict_validation": True,
-            **repair_metrics,
-        },
+        model_route=model_route,
         navigator_output=output,
         validator_result=validation.to_dict(),
         field_provenance=field_provenance,
@@ -172,10 +258,19 @@ def _try_field_level_model_output(
     rule_results: list[dict[str, Any]],
     retrieved: list[dict[str, Any]],
     known_cards: set[str],
+    scaffold_patched_fields: set[str],
     events: list[str],
     repair_metrics: dict[str, Any],
 ) -> tuple[dict[str, Any], Any, dict[str, str]] | None:
     fallback_output = canned_navigator_output(intake, rule_results, retrieved, floor)
+    fallback_scaffold = apply_navigation_scaffolding(
+        fallback_output,
+        retrieved_cards=retrieved,
+        rule_results=rule_results,
+        urgency_floor=floor,
+        confirmed_intake=intake,
+    )
+    fallback_output = fallback_scaffold.output
     accepted_raw_fields = accepted_raw_fields_from_failures(validation_failures)
     repair_context = {
         "intake": intake,
@@ -191,6 +286,7 @@ def _try_field_level_model_output(
         previous_output=raw_output,
         failures=validation_failures,
         urgency_floor=floor,
+        required_observation_targets=required_observation_targets(retrieved),
     )
     repair_metrics["repair_scope_count"] = len(focused_prompts)
     repair_metrics["repair_scopes"] = [focused_prompt.scope.name for focused_prompt in focused_prompts]
@@ -214,6 +310,13 @@ def _try_field_level_model_output(
         if not isinstance(repair_output, dict):
             events.append(f"navigator focused repair for {focused_prompt.scope.name} returned non-object output")
             continue
+        missing_source_cards = missing_mandatory_source_cards(focused_prompt.scope, repair_output)
+        if missing_source_cards:
+            events.append(
+                "navigator focused repair omitted mandatory source cards: "
+                + ", ".join(missing_source_cards)
+            )
+            continue
         for field in focused_prompt.scope.fields:
             if field in repair_output:
                 repaired_fields[field] = repair_output[field]
@@ -233,12 +336,119 @@ def _try_field_level_model_output(
         if merged_validation.passed:
             if merge_result.provenance == deterministic_field_provenance():
                 continue
+            _mark_deterministic_patch_fields(
+                merge_result.provenance,
+                scaffold_patched_fields | fallback_scaffold.patched_fields,
+            )
             events.append(event_text)
             return merge_result.output, merged_validation, merge_result.provenance
     events.append("navigator retry failed validation")
     return None
 
 
+def _try_handoff_competence_repair(
+    *,
+    client: ModelClient,
+    prompt: str,
+    output: dict[str, Any],
+    validation: Any,
+    field_provenance: dict[str, str],
+    floor: str,
+    intake: dict[str, Any],
+    rule_results: list[dict[str, Any]],
+    retrieved: list[dict[str, Any]],
+    known_cards: set[str],
+    events: list[str],
+    repair_metrics: dict[str, Any],
+) -> tuple[dict[str, Any], Any, dict[str, str]] | None:
+    before_metrics = score_handoff_readiness(
+        output,
+        actual_red_flag_rule_ids=[str(rule.get("rule_id")) for rule in rule_results if rule.get("rule_id")],
+        source_card_ids=output.get("source_cards", []),
+        validation_result=validation.to_dict(),
+    )
+    repair_metrics["handoff_readiness_before"] = before_metrics
+    if before_metrics.get("handoff_readiness_passed") is True:
+        repair_metrics["competence_repair_attempted"] = False
+        return None
+
+    failures = _handoff_competence_failures(before_metrics)
+    focused_prompts = [
+        item
+        for item in build_focused_repair_prompts(
+            original_prompt=prompt,
+            previous_output=output,
+            failures=failures,
+            urgency_floor=floor,
+            required_observation_targets=required_observation_targets(retrieved),
+        )
+        if item.scope.name == "handoff_note_sbar"
+    ]
+    if not focused_prompts:
+        return None
+
+    repair_metrics["competence_repair_attempted"] = True
+    repair_metrics["competence_repair_scope"] = "handoff_note_sbar"
+    repair_context = {
+        "intake": intake,
+        "rule_results": rule_results,
+        "retrieved_cards": retrieved,
+        "urgency_floor": floor,
+        "previous_output": output,
+        "validation_failures": failures,
+        "handoff_readiness_metrics": before_metrics,
+        "repair_scope": "handoff_note_sbar",
+    }
+    try:
+        repair_output = client.generate_json(focused_prompts[0].prompt, repair_context)
+    except ModelClientError:
+        events.append("navigator handoff competence repair backend failed")
+        return None
+    if not isinstance(repair_output, dict) or not isinstance(repair_output.get("handoff_note_sbar"), dict):
+        events.append("navigator handoff competence repair returned no handoff_note_sbar")
+        return None
+
+    candidate = dict(output)
+    candidate["handoff_note_sbar"] = repair_output["handoff_note_sbar"]
+    scaffold = apply_navigation_scaffolding(
+        candidate,
+        retrieved_cards=retrieved,
+        rule_results=rule_results,
+        urgency_floor=floor,
+        confirmed_intake=intake,
+    )
+    merged_validation = _validate_output(scaffold.output, known_cards, floor, intake, rule_results, retrieved)
+    after_metrics = score_handoff_readiness(
+        scaffold.output,
+        actual_red_flag_rule_ids=[str(rule.get("rule_id")) for rule in rule_results if rule.get("rule_id")],
+        source_card_ids=scaffold.output.get("source_cards", []),
+        validation_result=merged_validation.to_dict(),
+    )
+    repair_metrics["handoff_readiness_after"] = after_metrics
+    if merged_validation.passed and after_metrics.get("handoff_readiness_passed") is True:
+        merged_provenance = dict(field_provenance)
+        merged_provenance["handoff_note_sbar"] = MODEL_REPAIRED
+        repair_metrics["competence_repair_success"] = True
+        events.append("navigator handoff competence repaired by focused retry")
+        return scaffold.output, merged_validation, merged_provenance
+
+    repair_metrics["competence_repair_success"] = False
+    events.append("navigator handoff competence repair did not pass readiness")
+    return None
+
+
+def _handoff_competence_failures(metrics: dict[str, Any]) -> list[str]:
+    failures = ["handoff_note_sbar handoff_readiness_passed failed"]
+    for key, value in sorted(metrics.items()):
+        if key.startswith("sbar_") and value is False:
+            failures.append(f"handoff_note_sbar {key} failed")
+        elif key == "handoff_brevity_ok" and value is False:
+            failures.append("handoff_note_sbar handoff_brevity_ok failed")
+        elif key == "handoff_unsupported_fact_count" and value:
+            failures.append(f"handoff_note_sbar unsupported fact count: {value}")
+    return failures
+
+
 def _empty_repair_metrics() -> dict[str, Any]:
     return {
         "repair_attempt_count": 0,
@@ -247,9 +457,49 @@ def _empty_repair_metrics() -> dict[str, Any]:
         "repair_capped": False,
         "repair_latency_ms": 0.0,
         "repair_scopes": [],
+        "competence_repair_attempted": False,
+        "competence_repair_success": False,
+        "competence_repair_scope": None,
     }
 
 
+def _absorb_scaffold_trace(
+    result: NavigationScaffoldResult,
+    *,
+    scaffold_patched_fields: set[str],
+    filled_required_observation_ids: list[str],
+    model_selected_required_observation_ids: list[str],
+    invalid_selected_required_observation_ids: list[str],
+    stripped_trace_only_fields: list[str],
+    events: list[str],
+) -> None:
+    scaffold_patched_fields.update(result.patched_fields)
+    _extend_unique(filled_required_observation_ids, result.filled_required_observation_ids)
+    _extend_unique(model_selected_required_observation_ids, result.model_selected_required_observation_ids)
+    _extend_unique(invalid_selected_required_observation_ids, result.invalid_selected_required_observation_ids)
+    _extend_unique(stripped_trace_only_fields, result.stripped_trace_only_fields)
+    if result.stripped_trace_only_fields:
+        events.append("trace-only required-observation target ids stripped")
+    if result.invalid_selected_required_observation_ids:
+        events.append("invalid required-observation target ids ignored")
+    if result.filled_required_observation_ids:
+        events.append("required-observation targets filled deterministically")
+    if "handoff_note_sbar" in result.patched_fields:
+        events.append("handoff SBAR scaffold applied deterministically")
+
+
+def _extend_unique(items: list[str], values: list[str]) -> None:
+    for value in values:
+        if value not in items:
+            items.append(value)
+
+
+def _mark_deterministic_patch_fields(provenance: dict[str, str], fields: set[str]) -> None:
+    for field in fields:
+        if field in provenance:
+            provenance[field] = DETERMINISTIC_FALLBACK
+
+
 def _repair_prompt(
     original_prompt: str,
     previous_output: dict[str, Any],

figment/prompt_builder.py

@@ -5,9 +5,12 @@ from __future__ import annotations
 import json
 from typing import Any
 
+from .observation_targets import build_case_fact_ledger, build_handoff_note_sbar_template, required_observation_targets
 from .trace import stable_hash
 
 
+SUPPORT_SOURCE_CARD_IDS = ("SAFETY-BOUNDARIES-v1", "REFERRAL-SBAR-v1")
+
 SYSTEM_PROMPT = """You are Figment, an offline protocol navigator for a trained responder.
 You are NOT a clinician. Do not diagnose and do not prescribe.
 Use ONLY the protocol cards provided below.
@@ -16,10 +19,19 @@ Rules:
 - Extract relevant facts from messy notes and mark them as reported, missing, unclear, or conflicting.
 - Treat audio draft text only as confirmed intake if the medic accepted or edited it; never treat unconfirmed audio drafts as facts.
 - Select candidate protocol pathways only from retrieved cards and cite every card you rely on in source_cards.
+- Keep candidate_protocol_pathways focused on the clinical target/escalation pathway. Do not add SAFETY-BOUNDARIES-v1 or REFERRAL-SBAR-v1 as candidate pathways unless that support card itself is the target pathway.
 - Stay inside the retrieved cards.
 - Use allowed_facts_inventory as the complete fact boundary. Do not introduce handoff facts that are absent from confirmed intake, deterministic rules, or retrieved cards.
 - Fill every key shown in REQUIRED_JSON_SKELETON, including every handoff_note_sbar subkey.
 - Use required_observations_inventory when choosing missing_info_to_collect and next_observations_to_collect.
+- Choose required observation IDs before writing observation text.
+- Emit selected_required_observation_ids as a trace-only key when selecting any required_observation_targets. Include every mandatory_required_observation_target_id.
+- Use mandatory_required_observation_targets as the compact checklist for model-owned observation text. Copy each display_text into missing_info_to_collect before scaffold fill.
+- Include every mandatory_source_card_id in source_cards. This includes deterministic clinical cards and retrieved support cards used for safety/SBAR.
+- Cover required_observation_targets by id when writing missing_info_to_collect and next_observations_to_collect.
+- For each required_observation_target on a cited clinical source card, make the target display_text visible in missing_info_to_collect. Use the same display_text or a very close responder-facing wording; if already partly reported, frame it as confirm/document.
+- Use case_fact_ledger.present for supported facts and case_fact_ledger.absent_or_denied for symptoms that must not become red_flags.
+- Use handoff_note_sbar_template as the grounded SBAR starting point; rewrite only within confirmed intake, deterministic rules, and cited cards.
 - Do not discharge, clear for discharge, or send anyone home. Do not provide autonomous routing; route only to local protocol, supervisor, clinician, or emergency pathway when the cited cards support it.
 - Do not give a drug dose unless a cited card explicitly contains it.
 - If critical info is missing, list it in missing_info_to_collect and prioritize the next 3 to 5 observations to collect.
@@ -28,7 +40,7 @@ Rules:
 - Denied or absent symptoms are absence facts, not red_flags. If deterministic_red_flags is empty and the urgency floor is routine, do not escalate only because an emergency card was retrieved.
 - If no relevant card was retrieved, direct the responder to local protocol, supervisor, clinician, or emergency pathway; do not improvise.
 - Refuse out-of-scope or unsafe requests via safety_boundary.
-- Return ONLY JSON matching the required navigator schema. No chain-of-thought."""
+- Return ONLY JSON matching the required navigator schema, plus selected_required_observation_ids when required observation targets are selected. No chain-of-thought."""
 
 
 OUTPUT_SCHEMA = {
@@ -89,13 +101,30 @@ def build_prompt(
     audio_draft: dict[str, Any] | None = None,
 ) -> tuple[str, str]:
     card_payload = [item.get("card", item) for item in retrieved_cards]
+    mandatory_source_card_ids = _mandatory_source_card_ids(rule_results, card_payload)
+    observation_targets = required_observation_targets(card_payload)
+    mandatory_required_observation_target_ids = _mandatory_required_observation_target_ids(
+        observation_targets,
+        mandatory_source_card_ids,
+    )
     context = {
         "structured_intake": intake,
         "deterministic_red_flags": rule_results,
         "protocol_urgency_floor": urgency_floor,
         "retrieved_protocol_cards": card_payload,
         "allowed_facts_inventory": _allowed_facts_inventory(intake, card_payload, rule_results, urgency_floor),
+        "mandatory_source_card_ids": mandatory_source_card_ids,
         "required_observations_inventory": _required_observations_inventory(card_payload),
+        "required_observation_targets": observation_targets,
+        "mandatory_required_observation_target_ids": mandatory_required_observation_target_ids,
+        "mandatory_required_observation_targets": _mandatory_required_observation_targets(
+            observation_targets,
+            mandatory_required_observation_target_ids,
+        ),
+        "required_observation_generation_policy": _required_observation_generation_policy(),
+        "case_fact_ledger": build_case_fact_ledger(intake),
+        "handoff_note_sbar_template": build_handoff_note_sbar_template(intake, rule_results, urgency_floor),
+        "internal_generation_contract": _internal_generation_contract(),
         "routine_or_negated_case_guidance": ROUTINE_OR_NEGATED_CASE_GUIDANCE,
         "audio_draft_policy": {
             "audio_is_pre_navigation_only": True,
@@ -113,6 +142,86 @@ def build_prompt(
     return prompt, stable_hash(SYSTEM_PROMPT)
 
 
+def _mandatory_source_card_ids(rule_results: list[dict[str, Any]], card_payload: list[dict[str, Any]]) -> list[str]:
+    card_ids: list[str] = []
+    for rule in rule_results:
+        card_id = str(rule.get("card_id", "")).strip()
+        if card_id and card_id not in card_ids:
+            card_ids.append(card_id)
+    retrieved_ids = {str(card.get("card_id", "")).strip() for card in card_payload}
+    for card_id in SUPPORT_SOURCE_CARD_IDS:
+        if card_id in retrieved_ids and card_id not in card_ids:
+            card_ids.append(card_id)
+    return card_ids
+
+
+def _mandatory_required_observation_target_ids(
+    observation_targets: list[dict[str, Any]],
+    mandatory_source_card_ids: list[str],
+) -> list[str]:
+    mandatory_cards = set(mandatory_source_card_ids)
+    ids: list[str] = []
+    for target in observation_targets:
+        card_id = str(target.get("card_id", "")).strip()
+        target_id = str(target.get("id", "")).strip()
+        if card_id in SUPPORT_SOURCE_CARD_IDS:
+            continue
+        if card_id in mandatory_cards and target_id and target_id not in ids:
+            ids.append(target_id)
+    return ids
+
+
+def _mandatory_required_observation_targets(
+    observation_targets: list[dict[str, Any]],
+    mandatory_required_observation_target_ids: list[str],
+) -> list[dict[str, Any]]:
+    mandatory_ids = set(mandatory_required_observation_target_ids)
+    return [
+        {
+            "id": str(target.get("id", "")).strip(),
+            "card_id": str(target.get("card_id", "")).strip(),
+            "title": str(target.get("title", "")).strip(),
+            "display_text": str(target.get("display_text", "")).strip(),
+        }
+        for target in observation_targets
+        if str(target.get("id", "")).strip() in mandatory_ids
+    ]
+
+
+def _required_observation_generation_policy() -> dict[str, Any]:
+    return {
+        "model_owned_not_scaffold_filled": True,
+        "mandatory_required_observation_targets": (
+            "This compact list is the model-owned checklist. Every display_text in "
+            "mandatory_required_observation_targets must appear in missing_info_to_collect, even when "
+            "next_observations_to_collect stays prioritized and concise."
+        ),
+        "source_card_scope": (
+            "For every required_observation_target whose card_id is in source_cards and is not "
+            "SAFETY-BOUNDARIES-v1 or REFERRAL-SBAR-v1, the assistant output itself must make "
+            "that target visible in missing_info_to_collect."
+        ),
+        "text_requirement": (
+            "Use the target display_text exactly when it is short and responder-facing. If the "
+            "fact is already partly reported, still include the cue as confirm/document wording."
+        ),
+        "next_observations_to_collect": (
+            "Prioritize the most urgent 3 to 5 required observation display_text cues plus any "
+            "case-specific vital signs; missing_info_to_collect may carry the fuller set."
+        ),
+        "source_cards": (
+            "source_cards must include every mandatory_source_card_id. The mandatory list includes "
+            "deterministic clinical cards plus retrieved SAFETY-BOUNDARIES-v1 and REFERRAL-SBAR-v1 "
+            "when those support cards are used for safety or SBAR fields."
+        ),
+        "selected_required_observation_ids": (
+            "When selected_required_observation_ids is emitted, include every "
+            "mandatory_required_observation_target_id and any additional target id whose display_text is visible "
+            "in missing_info_to_collect or next_observations_to_collect. This key is trace-only and will be stripped."
+        ),
+    }
+
+
 def _allowed_facts_inventory(
     intake: dict[str, Any],
     card_payload: list[dict[str, Any]],
@@ -228,6 +337,28 @@ def _safe_audio_draft_context(audio_draft: dict[str, Any] | None) -> dict[str, A
     }
 
 
+def _internal_generation_contract() -> dict[str, Any]:
+    return {
+        "trace_only_keys": ["selected_required_observation_ids"],
+        "required_when_required_observation_targets_selected": ["selected_required_observation_ids"],
+        "selected_required_observation_ids": (
+            "selected_required_observation_ids must be emitted when any required_observation_targets are selected. "
+            "It must include every mandatory_required_observation_target_id and may include additional ids from "
+            "required_observation_targets that are covered in missing_info_to_collect or "
+            "next_observations_to_collect. Select ids first, then write recognizable responder-facing observation "
+            "text for each selected id. This key is trace-only."
+        ),
+        "strip_before_user_display": True,
+    }
+
+
+def _first_text(*values: Any) -> str:
+    for value in values:
+        if _has_value(value):
+            return str(value).strip()
+    return ""
+
+
 def _has_value(value: Any) -> bool:
     if value is None:
         return False

figment/rules.py

@@ -43,6 +43,18 @@ def _find(patterns: tuple[str, ...], text: str) -> str | None:
     return None
 
 
+def _find_unnegated(
+    patterns: tuple[str, ...],
+    text: str,
+    negation_check: Any,
+) -> str | None:
+    for pattern in patterns:
+        for match in re.finditer(pattern, text, re.IGNORECASE):
+            if not negation_check(text, match):
+                return match.group(0).strip()
+    return None
+
+
 def _is_pediatric(intake: Mapping[str, Any], text: str) -> bool:
     age = str(intake.get("patient_age", "")).strip().lower()
     month_match = re.search(r"\b(\d{1,3})\s*(?:mo|mos|month|months)\b", age)
@@ -104,6 +116,31 @@ def _has_positive_fever(text: str) -> bool:
     return False
 
 
+def _is_negated_chest_match(text: str, match: re.Match[str]) -> bool:
+    start = match.start()
+    clause_start = max(text.rfind(boundary, 0, start) for boundary in (".", ";", "!", "?", "\n"))
+    prefix = text[clause_start + 1 : start].lower()
+
+    direct_negation = re.search(
+        r"\b(?:no|not|without|denies|denied|negative for|reports no)\s+"
+        r"(?:any\s+|active\s+|current(?:ly)?\s+|reported\s+)?$",
+        prefix,
+    )
+    if direct_negation:
+        return True
+
+    denial_marker = None
+    for marker in re.finditer(r"\b(?:denies|denied|negative for)\b", prefix):
+        denial_marker = marker
+    if not denial_marker:
+        return False
+
+    between = prefix[denial_marker.end() :]
+    if re.search(r"\b(?:but|however|except|except for|now|currently)\b", between):
+        return False
+    return True
+
+
 def _rule(rule_id: str, label: str, urgency: Urgency, evidence: str, card_id: str) -> RuleResult:
     return RuleResult(rule_id=rule_id, label=label, urgency=urgency, evidence=evidence, card_id=card_id)
 
@@ -166,7 +203,7 @@ def _pregnancy_danger(intake: Mapping[str, Any], text: str) -> RuleResult | None
 
 
 def _chest_pain(_: Mapping[str, Any], text: str) -> RuleResult | None:
-    evidence = _find(
+    evidence = _find_unnegated(
         (
             r"\bchest pain\b",
             r"\bchest pressure\b",
@@ -174,6 +211,7 @@ def _chest_pain(_: Mapping[str, Any], text: str) -> RuleResult | None:
             r"\bchest pain with (?:shortness of breath|sweating|fainting|severe weakness)\b",
         ),
         text,
+        _is_negated_chest_match,
     )
     if not evidence:
         return None

figment/validators.py

@@ -155,7 +155,13 @@ def validate_navigator_output(
     retrieved_cards_by_id = _retrieved_cards_by_id(retrieved_cards or [])
     if retrieved_card_ids is None and retrieved_cards_by_id:
         retrieved_card_ids = set(retrieved_cards_by_id)
+    fired_rule_card_ids = {
+        str(rule.get("card_id", "")).strip()
+        for rule in rule_results or []
+        if str(rule.get("card_id", "")).strip()
+    }
     allowed_cards = set(retrieved_card_ids) if retrieved_card_ids is not None else known_cards
+    allowed_cards.update(fired_rule_card_ids & known_cards)
     source_cards = output.get("source_cards")
     if not isinstance(source_cards, list) or not source_cards:
         result.add("source_cards must be a non-empty list")
@@ -265,9 +271,16 @@ def _validate_missing_observations_against_cards(
         required_observations = card.get("required_observations", [])
         if not isinstance(required_observations, list) or not required_observations:
             continue
-        required_sets = [_grounding_tokens(observation) for observation in required_observations]
-        if not any(tokens & observation_tokens for tokens in required_sets):
-            result.add(f"missing_info_to_collect does not reference required observations for {card_id}")
+        missing_required_observations = []
+        for observation in required_observations:
+            required_tokens = _grounding_tokens(observation)
+            if required_tokens and not required_tokens <= observation_tokens:
+                missing_required_observations.append(str(observation))
+        if missing_required_observations:
+            result.add(
+                "missing_info_to_collect does not reference required observations for "
+                f"{card_id}: {', '.join(missing_required_observations[:8])}"
+            )
 
 
 def _is_negated_safety_phrase(text: str, match_start: int) -> bool:

scripts/run_eval.py

@@ -5,31 +5,43 @@ from __future__ import annotations
 import argparse
 from dataclasses import replace
 import json
+import os
 from pathlib import Path
 import sys
 from time import perf_counter
 from typing import Any
+import urllib.error
+import urllib.parse
+import urllib.request
 
 PROJECT_ROOT = Path(__file__).resolve().parents[1]
 if str(PROJECT_ROOT) not in sys.path:
     sys.path.insert(0, str(PROJECT_ROOT))
 
-from figment.config import FigmentConfig
-from figment.eval_metrics import score_expected_labels, summarize_eval_records
-from figment.field_provenance import (
+from figment.config import FigmentConfig  # noqa: E402
+from figment.eval_metrics import score_expected_labels, score_handoff_readiness, summarize_eval_records  # noqa: E402
+from figment.field_provenance import (  # noqa: E402
+    DETERMINISTIC_FALLBACK,
+    MODEL_REPAIRED,
     accepted_raw_fields_from_failures,
     deterministic_field_provenance,
     has_deterministic_patches,
     merge_field_provenance,
     model_raw_field_provenance,
+)  # noqa: E402
+from figment.focused_repair import build_focused_repair_prompts, missing_mandatory_source_cards  # noqa: E402
+from figment.harness_evidence import build_harness_evidence  # noqa: E402
+from figment.model_client import ModelClient, ModelClientError, canned_navigator_output  # noqa: E402
+from figment.observation_targets import (  # noqa: E402
+    NavigationScaffoldResult,
+    apply_navigation_scaffolding,
+    required_observation_targets,
 )
-from figment.focused_repair import build_focused_repair_prompts
-from figment.model_client import ModelClient, ModelClientError, canned_navigator_output
-from figment.prompt_builder import build_prompt
-from figment.retrieval import known_card_ids, query_from_intake, search_protocol_cards
-from figment.rules import run_red_flag_checks
-from figment.trace import stable_hash
-from figment.validators import urgency_floor_from_rules, validate_navigator_output
+from figment.prompt_builder import build_prompt  # noqa: E402
+from figment.retrieval import known_card_ids, query_from_intake, search_protocol_cards  # noqa: E402
+from figment.rules import run_red_flag_checks  # noqa: E402
+from figment.trace import derive_model_route, stable_hash  # noqa: E402
+from figment.validators import urgency_floor_from_rules, validate_navigator_output  # noqa: E402
 
 
 DEFAULT_CASE_GLOB = "data/eval/*.jsonl"
@@ -78,7 +90,10 @@ def run_eval(
     else:
         for record in records:
             sys.stdout.write(f"{json.dumps(record, sort_keys=True)}\n")
-    return _summarize(records, config, case_paths, output_path)
+    summary = _summarize(records, config, case_paths, output_path)
+    if output_path is not None:
+        _write_eval_bundle_metadata(summary, records, config, case_paths, output_path)
+    return summary
 
 
 def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any]:
@@ -102,9 +117,22 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
     repair_attempted = False
     fallback_used = False
     fallback_reason: str | None = None
+    competence_repair_attempted = False
+    competence_repair_success = False
+    competence_repair_scope: str | None = None
+    competence_repaired_output: dict[str, Any] | None = None
+    competence_repair_validation = {"passed": False, "failures": ["competence repair not attempted"]}
+    scaffolded_model_output: dict[str, Any] | None = None
+    handoff_readiness_before: dict[str, Any] | None = None
+    handoff_readiness_after: dict[str, Any] | None = None
     final_output: dict[str, Any]
     final_validation: dict[str, Any]
     field_provenance: dict[str, str] = {}
+    scaffold_patched_fields: set[str] = set()
+    filled_required_observation_ids: list[str] = []
+    model_selected_required_observation_ids: list[str] = []
+    invalid_selected_required_observation_ids: list[str] = []
+    stripped_trace_only_fields: list[str] = []
 
     context = {
         "intake": intake,
@@ -116,7 +144,7 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
     if config.model_backend == "canned":
         fallback_reason = "canned_backend"
         fallback_used = True
-        fallback_output, fallback_validation = _run_fallback(
+        fallback_output, fallback_validation, fallback_scaffold = _run_fallback(
             intake,
             rule_results,
             retrieved,
@@ -124,6 +152,14 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
             known_cards,
             retrieved_ids,
         )
+        _absorb_scaffold_trace(
+            fallback_scaffold,
+            scaffold_patched_fields=scaffold_patched_fields,
+            filled_required_observation_ids=filled_required_observation_ids,
+            model_selected_required_observation_ids=model_selected_required_observation_ids,
+            invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+            stripped_trace_only_fields=stripped_trace_only_fields,
+        )
         final_output = fallback_output
         final_validation = fallback_validation
         field_provenance = deterministic_field_provenance()
@@ -131,18 +167,74 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
         client = ModelClient(config)
         try:
             raw_output = client.generate_json(prompt, context)
-            raw_validation = _validate_output(raw_output, known_cards, floor, intake, rule_results, retrieved, retrieved_ids)
+            scaffold_result = apply_navigation_scaffolding(
+                raw_output,
+                retrieved_cards=retrieved,
+                rule_results=rule_results,
+                urgency_floor=floor,
+                confirmed_intake=intake,
+            )
+            scaffolded_model_output = scaffold_result.output
+            _absorb_scaffold_trace(
+                scaffold_result,
+                scaffold_patched_fields=scaffold_patched_fields,
+                filled_required_observation_ids=filled_required_observation_ids,
+                model_selected_required_observation_ids=model_selected_required_observation_ids,
+                invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+                stripped_trace_only_fields=stripped_trace_only_fields,
+            )
+            raw_validation = _validate_output(
+                scaffolded_model_output,
+                known_cards,
+                floor,
+                intake,
+                rule_results,
+                retrieved,
+                retrieved_ids,
+            )
         except ModelClientError as exc:
             raw_validation = {"passed": False, "failures": [f"model backend error: {exc}"]}
             fallback_reason = "model_backend_error"
 
-        if raw_output is not None and raw_validation["passed"]:
-            final_output = raw_output
+        if scaffolded_model_output is not None and raw_validation["passed"]:
+            final_output = scaffolded_model_output
             final_validation = raw_validation
             field_provenance = model_raw_field_provenance()
+            _mark_deterministic_patch_fields(field_provenance, scaffold_patched_fields)
+            patch_repair_failures = _observation_patch_repair_failures(
+                filled_required_observation_ids,
+                scaffold_patched_fields,
+            )
+            if patch_repair_failures and raw_output is not None:
+                (
+                    repaired_output,
+                    repair_validation,
+                    repair_attempted,
+                    merged_output,
+                    merged_validation,
+                    merged_field_provenance,
+                ) = _try_field_level_model_output(
+                    client=client,
+                    prompt=prompt,
+                    context=context,
+                    raw_output=raw_output,
+                    validation_failures=patch_repair_failures,
+                    fallback_output=scaffolded_model_output,
+                    known_cards=known_cards,
+                    floor=floor,
+                    intake=intake,
+                    rule_results=rule_results,
+                    retrieved=retrieved,
+                    retrieved_ids=retrieved_ids,
+                    scaffold_patched_fields=scaffold_patched_fields,
+                )
+                if merged_output is not None and merged_validation is not None:
+                    final_output = merged_output
+                    final_validation = merged_validation
+                    field_provenance = merged_field_provenance
         else:
-            if raw_output is not None:
-                fallback_output, fallback_validation = _run_fallback(
+            if scaffolded_model_output is not None:
+                fallback_output, fallback_validation, fallback_scaffold = _run_fallback(
                     intake,
                     rule_results,
                     retrieved,
@@ -161,7 +253,7 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
                     client=client,
                     prompt=prompt,
                     context=context,
-                    raw_output=raw_output,
+                    raw_output=scaffolded_model_output,
                     validation_failures=raw_validation["failures"],
                     fallback_output=fallback_output,
                     known_cards=known_cards,
@@ -170,20 +262,41 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
                     rule_results=rule_results,
                     retrieved=retrieved,
                     retrieved_ids=retrieved_ids,
+                    scaffold_patched_fields=scaffold_patched_fields,
                 )
                 if merged_output is not None and merged_validation is not None:
                     final_output = merged_output
                     final_validation = merged_validation
                     field_provenance = merged_field_provenance
+                    if (
+                        field_provenance.get("missing_info_to_collect") == DETERMINISTIC_FALLBACK
+                        or field_provenance.get("next_observations_to_collect") == DETERMINISTIC_FALLBACK
+                    ):
+                        _absorb_scaffold_trace(
+                            fallback_scaffold,
+                            scaffold_patched_fields=scaffold_patched_fields,
+                            filled_required_observation_ids=filled_required_observation_ids,
+                            model_selected_required_observation_ids=model_selected_required_observation_ids,
+                            invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+                            stripped_trace_only_fields=stripped_trace_only_fields,
+                        )
                 else:
                     fallback_reason = fallback_reason or "navigator_validation_failure"
                     fallback_used = True
                     final_output = fallback_output
                     final_validation = fallback_validation
                     field_provenance = deterministic_field_provenance()
+                    _absorb_scaffold_trace(
+                        fallback_scaffold,
+                        scaffold_patched_fields=scaffold_patched_fields,
+                        filled_required_observation_ids=filled_required_observation_ids,
+                        model_selected_required_observation_ids=model_selected_required_observation_ids,
+                        invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+                        stripped_trace_only_fields=stripped_trace_only_fields,
+                    )
             else:
                 fallback_used = True
-                fallback_output, fallback_validation = _run_fallback(
+                fallback_output, fallback_validation, fallback_scaffold = _run_fallback(
                     intake,
                     rule_results,
                     retrieved,
@@ -191,17 +304,93 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
                     known_cards,
                     retrieved_ids,
                 )
+                _absorb_scaffold_trace(
+                    fallback_scaffold,
+                    scaffold_patched_fields=scaffold_patched_fields,
+                    filled_required_observation_ids=filled_required_observation_ids,
+                    model_selected_required_observation_ids=model_selected_required_observation_ids,
+                    invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+                    stripped_trace_only_fields=stripped_trace_only_fields,
+                )
                 final_output = fallback_output
                 final_validation = fallback_validation
                 field_provenance = deterministic_field_provenance()
 
+    if final_validation["passed"] and config.model_backend != "canned":
+        handoff_readiness_before = score_handoff_readiness(
+            final_output,
+            actual_red_flag_rule_ids=[str(rule.get("rule_id")) for rule in rule_results if rule.get("rule_id")],
+            source_card_ids=final_output.get("source_cards", []),
+            validation_result=final_validation,
+        )
+        if handoff_readiness_before.get("handoff_readiness_passed") is not True:
+            competence_fallback_output, _competence_fallback_validation, competence_fallback_scaffold = _run_fallback(
+                intake,
+                rule_results,
+                retrieved,
+                floor,
+                known_cards,
+                retrieved_ids,
+            )
+            (
+                competence_repaired_output,
+                competence_repair_validation,
+                competence_repair_attempted,
+                competence_merged_output,
+                competence_merged_validation,
+                competence_merged_field_provenance,
+            ) = _try_field_level_model_output(
+                client=client,
+                prompt=prompt,
+                context={
+                    **context,
+                    "handoff_readiness_metrics": handoff_readiness_before,
+                },
+                raw_output=final_output,
+                validation_failures=_handoff_competence_failures(handoff_readiness_before),
+                fallback_output=competence_fallback_output,
+                known_cards=known_cards,
+                floor=floor,
+                intake=intake,
+                rule_results=rule_results,
+                retrieved=retrieved,
+                retrieved_ids=retrieved_ids,
+                scaffold_patched_fields=scaffold_patched_fields,
+            )
+            competence_repair_scope = "handoff_note_sbar" if competence_repair_attempted else None
+            if competence_merged_output is not None and competence_merged_validation is not None:
+                after = score_handoff_readiness(
+                    competence_merged_output,
+                    actual_red_flag_rule_ids=[str(rule.get("rule_id")) for rule in rule_results if rule.get("rule_id")],
+                    source_card_ids=competence_merged_output.get("source_cards", []),
+                    validation_result=competence_merged_validation,
+                )
+                handoff_readiness_after = after
+                if after.get("handoff_readiness_passed") is True:
+                    final_output = competence_merged_output
+                    final_validation = competence_merged_validation
+                    field_provenance = competence_merged_field_provenance
+                    competence_repair_success = True
+                    if (
+                        field_provenance.get("missing_info_to_collect") == DETERMINISTIC_FALLBACK
+                        or field_provenance.get("next_observations_to_collect") == DETERMINISTIC_FALLBACK
+                    ):
+                        _absorb_scaffold_trace(
+                            competence_fallback_scaffold,
+                            scaffold_patched_fields=scaffold_patched_fields,
+                            filled_required_observation_ids=filled_required_observation_ids,
+                            model_selected_required_observation_ids=model_selected_required_observation_ids,
+                            invalid_selected_required_observation_ids=invalid_selected_required_observation_ids,
+                            stripped_trace_only_fields=stripped_trace_only_fields,
+                        )
+
     field_level_fallback_used = has_deterministic_patches(field_provenance)
 
-    raw_success = raw_attempted and raw_validation["passed"]
+    raw_success = raw_attempted and raw_validation["passed"] and not scaffold_patched_fields
     repair_success = repair_attempted and repair_validation["passed"]
     fallback_success = fallback_used and fallback_validation["passed"]
     fallback_tier = "canned" if fallback_used else "configured"
-    competence_success = bool(raw_success or repair_success)
+    competence_success = bool(raw_success or repair_success or competence_repair_success)
     model_route = {
         "model_stack": config.model_stack,
         "model_backend": config.model_backend,
@@ -209,7 +398,24 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
         "fallback_tier": fallback_tier,
         "fallback_reason": fallback_reason,
         "field_level_fallback_used": field_level_fallback_used,
+        "deterministic_scaffold_patched_fields": sorted(scaffold_patched_fields),
+        "filled_required_observation_ids": filled_required_observation_ids,
+        "model_selected_required_observation_ids": model_selected_required_observation_ids,
+        "invalid_selected_required_observation_ids": invalid_selected_required_observation_ids,
+        "stripped_trace_only_fields": stripped_trace_only_fields,
     }
+    model_route = derive_model_route(model_route, final_validation, [], field_provenance=field_provenance)
+    harness_evidence = build_harness_evidence(
+        confirmed_intake=intake,
+        retrieved_card_ids=retrieved_ids,
+        rule_results=rule_results,
+        urgency_floor=floor,
+        validator_result=final_validation,
+        final_output=final_output,
+        model_route=model_route,
+    )
+    final_output = dict(final_output)
+    final_output["harness_evidence"] = harness_evidence
     trace_payload = {
         "case_id": case["case_id"],
         "input_hash": stable_hash(intake),
@@ -217,6 +423,7 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
         "retrieved_card_ids": retrieved_ids,
         "prompt_template_hash": prompt_hash,
         "model_route": model_route,
+        "harness_evidence": harness_evidence,
         "navigator_output": final_output,
         "validator_result": final_validation,
         "field_provenance": field_provenance,
@@ -236,7 +443,11 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
         "expected_min_protocol_urgency": case.get("expected_min_protocol_urgency"),
         "expected_red_flag_rule_ids": case.get("expected_red_flag_rule_ids", []),
         "expected_source_card_ids": case.get("expected_source_card_ids", []),
+        "expected_candidate_pathway_card_ids": case.get("expected_candidate_pathway_card_ids", []),
         "expected_missing_observations": case.get("expected_missing_observations", []),
+        "expected_model_observation_cues": case.get("expected_model_observation_cues", []),
+        "expected_handoff_cues": case.get("expected_handoff_cues", []),
+        "expected_harness_evidence_cues": case.get("expected_harness_evidence_cues", []),
         "forbidden_behavior": case.get("forbidden_behavior", []),
         "actual_red_flag_rule_ids": [rule["rule_id"] for rule in rule_results],
         "actual_protocol_urgency": final_output.get("protocol_urgency"),
@@ -249,20 +460,36 @@ def _evaluate_case(case: dict[str, Any], config: FigmentConfig) -> dict[str, Any
         "fallback_tier": fallback_tier,
         "fallback_reason": fallback_reason,
         "field_level_fallback_used": field_level_fallback_used,
+        "deterministic_scaffold_patched_fields": sorted(scaffold_patched_fields),
+        "filled_required_observation_ids": filled_required_observation_ids,
+        "model_selected_required_observation_ids": model_selected_required_observation_ids,
+        "invalid_selected_required_observation_ids": invalid_selected_required_observation_ids,
+        "stripped_trace_only_fields": stripped_trace_only_fields,
         "raw_configured_model_attempted": raw_attempted,
         "raw_configured_model_success": raw_success,
         "repair_attempted": repair_attempted,
         "repair_success": repair_success,
+        "validation_repair_attempted": repair_attempted,
+        "validation_repair_success": repair_success,
+        "competence_repair_attempted": competence_repair_attempted,
+        "competence_repair_success": competence_repair_success,
+        "competence_repair_scope": competence_repair_scope,
+        "handoff_readiness_before_competence_repair": handoff_readiness_before,
+        "handoff_readiness_after_competence_repair": handoff_readiness_after,
         "canned_fallback_used": fallback_used,
         "canned_fallback_success": fallback_success,
         "competence_success": competence_success,
         "raw_validation": raw_validation,
         "repair_validation": repair_validation,
+        "competence_repair_validation": competence_repair_validation,
         "fallback_validation": fallback_validation,
         "validation_result": final_validation,
         "final_validation": final_validation,
+        "harness_evidence": harness_evidence,
         "raw_model_output": raw_output,
+        "scaffolded_model_output": scaffolded_model_output,
         "repaired_output": repaired_output,
+        "competence_repaired_output": competence_repaired_output,
         "fallback_output": fallback_output,
         "final_output": final_output,
         "field_provenance": field_provenance,
@@ -280,10 +507,56 @@ def _run_fallback(
     floor: str,
     known_cards: set[str],
     retrieved_ids: list[str],
-) -> tuple[dict[str, Any], dict[str, Any]]:
+) -> tuple[dict[str, Any], dict[str, Any], NavigationScaffoldResult]:
     output = canned_navigator_output(intake, rule_results, retrieved, floor)
+    scaffold = apply_navigation_scaffolding(
+        output,
+        retrieved_cards=retrieved,
+        rule_results=rule_results,
+        urgency_floor=floor,
+        confirmed_intake=intake,
+    )
+    output = scaffold.output
     validation = _validate_output(output, known_cards, floor, intake, rule_results, retrieved, retrieved_ids)
-    return output, validation
+    return output, validation, scaffold
+
+
+def _absorb_scaffold_trace(
+    result: NavigationScaffoldResult,
+    *,
+    scaffold_patched_fields: set[str],
+    filled_required_observation_ids: list[str],
+    model_selected_required_observation_ids: list[str],
+    invalid_selected_required_observation_ids: list[str],
+    stripped_trace_only_fields: list[str],
+) -> None:
+    scaffold_patched_fields.update(result.patched_fields)
+    _extend_unique(filled_required_observation_ids, result.filled_required_observation_ids)
+    _extend_unique(model_selected_required_observation_ids, result.model_selected_required_observation_ids)
+    _extend_unique(invalid_selected_required_observation_ids, result.invalid_selected_required_observation_ids)
+    _extend_unique(stripped_trace_only_fields, result.stripped_trace_only_fields)
+
+
+def _extend_unique(items: list[str], values: list[str]) -> None:
+    for value in values:
+        if value not in items:
+            items.append(value)
+
+
+def _merge_observation_repair_values(previous_value: Any, repair_value: Any) -> list[str]:
+    merged: list[str] = []
+    for value in _coerce_text_list(previous_value) + _coerce_text_list(repair_value):
+        if value not in merged:
+            merged.append(value)
+    return merged
+
+
+def _coerce_text_list(value: Any) -> list[str]:
+    if isinstance(value, list):
+        return [str(item).strip() for item in value if str(item).strip()]
+    if isinstance(value, str) and value.strip():
+        return [value.strip()]
+    return []
 
 
 def _validate_output(
@@ -321,6 +594,7 @@ def _try_field_level_model_output(
     rule_results: list[dict[str, Any]],
     retrieved: list[dict[str, Any]],
     retrieved_ids: list[str],
+    scaffold_patched_fields: set[str],
 ) -> tuple[dict[str, Any] | None, dict[str, Any], bool, dict[str, Any] | None, dict[str, Any] | None, dict[str, str]]:
     accepted_raw_fields = accepted_raw_fields_from_failures(validation_failures)
     repaired_fields: dict[str, Any] = {}
@@ -331,6 +605,7 @@ def _try_field_level_model_output(
         previous_output=raw_output,
         failures=validation_failures,
         urgency_floor=floor,
+        required_observation_targets=required_observation_targets(retrieved),
     ):
         repair_attempted = True
         try:
@@ -349,9 +624,24 @@ def _try_field_level_model_output(
         if not isinstance(repair_output, dict):
             repair_validation = {"passed": False, "failures": ["repair output was not an object"]}
             continue
+        missing_source_cards = missing_mandatory_source_cards(focused_prompt.scope, repair_output)
+        if missing_source_cards:
+            repair_validation = {
+                "passed": False,
+                "failures": [
+                    f"repair omitted mandatory source card {card_id}" for card_id in missing_source_cards
+                ],
+            }
+            continue
         for field in focused_prompt.scope.fields:
             if field in repair_output:
-                repaired_fields[field] = repair_output[field]
+                if focused_prompt.scope.name == "missing_observations":
+                    repaired_fields[field] = _merge_observation_repair_values(
+                        raw_output.get(field),
+                        repair_output[field],
+                    )
+                else:
+                    repaired_fields[field] = repair_output[field]
 
     merge_candidates = []
     if repaired_fields:
@@ -376,6 +666,7 @@ def _try_field_level_model_output(
         if merged_validation["passed"]:
             if merge_result.provenance == deterministic_field_provenance():
                 continue
+            _mark_deterministic_patch_fields(merge_result.provenance, scaffold_patched_fields)
             if candidate_repaired_fields:
                 repair_validation = merged_validation
             return (
@@ -391,6 +682,41 @@ def _try_field_level_model_output(
     return None, repair_validation, repair_attempted, None, None, {}
 
 
+def _mark_deterministic_patch_fields(provenance: dict[str, str], fields: set[str]) -> None:
+    for field in fields:
+        if field in provenance and provenance[field] != MODEL_REPAIRED:
+            provenance[field] = DETERMINISTIC_FALLBACK
+
+
+def _observation_patch_repair_failures(
+    filled_required_observation_ids: list[str],
+    scaffold_patched_fields: set[str],
+) -> list[str]:
+    if not {"missing_info_to_collect", "next_observations_to_collect"} & scaffold_patched_fields:
+        return []
+    card_ids: list[str] = []
+    for target_id in filled_required_observation_ids:
+        card_id, separator, _index = str(target_id).partition("::required_observation::")
+        if separator and card_id and card_id not in card_ids:
+            card_ids.append(card_id)
+    return [
+        f"missing_info_to_collect does not reference required observations for {card_id}"
+        for card_id in card_ids
+    ]
+
+
+def _handoff_competence_failures(metrics: dict[str, Any]) -> list[str]:
+    failures = ["handoff_note_sbar handoff_readiness_passed failed"]
+    for key, value in sorted(metrics.items()):
+        if key.startswith("sbar_") and value is False:
+            failures.append(f"handoff_note_sbar {key} failed")
+        elif key == "handoff_brevity_ok" and value is False:
+            failures.append("handoff_note_sbar handoff_brevity_ok failed")
+        elif key == "handoff_unsupported_fact_count" and value:
+            failures.append(f"handoff_note_sbar unsupported fact count: {value}")
+    return failures
+
+
 def _repair_prompt(
     original_prompt: str,
     previous_output: dict[str, Any],
@@ -442,6 +768,9 @@ def _summarize(
             "output_path": str(output_path) if output_path else None,
         }
     )
+    runtime_errors = _runtime_error_summary(records)
+    summary["runtime_error_summary"] = runtime_errors
+    summary["scored_reporting_eligible"] = runtime_errors["critical_runtime_error_count"] == 0
     if config.model_backend == "llama_cpp":
         summary["local_llm_evidence"] = _local_llm_evidence_summary(summary, config)
     return summary
@@ -456,6 +785,15 @@ def _local_llm_evidence_summary(summary: dict[str, Any], config: FigmentConfig)
         "model_stack": config.model_stack,
         "model_id": config.active_model_id,
         "llama_base_url": config.llama_base_url,
+        "server_command": os.getenv("LLAMA_SERVER_COMMAND") or None,
+        "gguf_path": os.getenv("LOCAL_GGUF_PATH") or os.getenv("LLAMA_ARG_MODEL") or None,
+        "gguf_sha256": os.getenv("LOCAL_GGUF_SHA256") or None,
+        "n_ctx": _optional_int_env("LLAMA_N_CTX") or _optional_int_env("LLAMA_ARG_CTX_SIZE"),
+        "n_parallel": _optional_int_env("LLAMA_N_PARALLEL") or _optional_int_env("LLAMA_ARG_N_PARALLEL"),
+        "prompt_cache": os.getenv("LLAMA_PROMPT_CACHE") or None,
+        "models_endpoint": _models_endpoint_metadata(config.llama_base_url),
+        "runtime_error_summary": summary.get("runtime_error_summary", {}),
+        "scored_reporting_eligible": summary.get("scored_reporting_eligible"),
         "total_cases": total_cases,
         "competence_successes": competence_successes,
         "raw_configured_model_successes": summary.get("raw_configured_model_successes", 0),
@@ -472,6 +810,109 @@ def _local_llm_evidence_summary(summary: dict[str, Any], config: FigmentConfig)
     }
 
 
+def _runtime_error_summary(records: list[dict[str, Any]]) -> dict[str, Any]:
+    markers = {
+        "context_size_exceeded": ("Context size has been exceeded",),
+        "kv_cache_failure": ("failed to find free space in the KV cache", "KV cache"),
+        "server_http_500": ("http_status=500", "HTTP Error 500", " 500 "),
+    }
+    text_by_record = {
+        str(record.get("case_id") or index): json.dumps(
+            {
+                "raw_validation": record.get("raw_validation"),
+                "repair_validation": record.get("repair_validation"),
+                "competence_repair_validation": record.get("competence_repair_validation"),
+                "fallback_validation": record.get("fallback_validation"),
+                "final_validation": record.get("final_validation"),
+            },
+            sort_keys=True,
+        )
+        for index, record in enumerate(records, start=1)
+    }
+    summary: dict[str, Any] = {
+        "context_size_exceeded": False,
+        "kv_cache_failure": False,
+        "server_http_500": False,
+        "critical_runtime_error_count": 0,
+        "affected_case_ids": [],
+    }
+    affected: set[str] = set()
+    for case_id, text in text_by_record.items():
+        for key, key_markers in markers.items():
+            if any(marker in text for marker in key_markers):
+                summary[key] = True
+                affected.add(case_id)
+    summary["affected_case_ids"] = sorted(affected)
+    summary["critical_runtime_error_count"] = sum(
+        int(bool(summary[key])) for key in ("context_size_exceeded", "kv_cache_failure", "server_http_500")
+    )
+    return summary
+
+
+def _models_endpoint_metadata(base_url: str) -> dict[str, Any]:
+    url = _openai_models_url(base_url)
+    try:
+        with urllib.request.urlopen(url, timeout=2.0) as response:
+            payload = json.loads(response.read().decode("utf-8"))
+    except (OSError, TimeoutError, urllib.error.URLError, json.JSONDecodeError) as exc:
+        return {"url": url, "available": False, "error": str(exc)[:200]}
+    return {"url": url, "available": True, "payload": payload}
+
+
+def _openai_models_url(base_url: str) -> str:
+    parts = urllib.parse.urlsplit(base_url.strip())
+    path = parts.path.rstrip("/")
+    if path.endswith("/v1"):
+        path = f"{path}/models"
+    elif path.endswith("/models"):
+        pass
+    else:
+        path = f"{path}/models" if path else "/v1/models"
+    return urllib.parse.urlunsplit((parts.scheme, parts.netloc, path, "", ""))
+
+
+def _optional_int_env(name: str) -> int | None:
+    value = os.getenv(name, "").strip()
+    if not value:
+        return None
+    try:
+        return int(value)
+    except ValueError:
+        return None
+
+
+def _write_eval_bundle_metadata(
+    summary: dict[str, Any],
+    records: list[dict[str, Any]],
+    config: FigmentConfig,
+    case_paths: list[Path],
+    output_path: Path,
+) -> None:
+    output_dir = output_path.parent
+    output_dir.mkdir(parents=True, exist_ok=True)
+    summary_path = output_dir / "eval_summary.json"
+    manifest_path = output_dir / "eval_evidence_manifest.json"
+    summary_path.write_text(json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    manifest = {
+        "output_jsonl": str(output_path),
+        "summary_json": str(summary_path),
+        "case_paths": [str(path) for path in case_paths],
+        "model_backend": config.model_backend,
+        "model_stack": config.model_stack,
+        "active_model_id": config.active_model_id,
+        "total_cases": len(records),
+        "trace_hashes": [
+            {"case_id": record.get("case_id"), "trace_hash": record.get("trace_hash")}
+            for record in records
+        ],
+        "all_trace_hashes_present": all(bool(record.get("trace_hash")) for record in records),
+        "runtime_error_summary": summary.get("runtime_error_summary", {}),
+        "scored_reporting_eligible": summary.get("scored_reporting_eligible"),
+        "local_llm_evidence": summary.get("local_llm_evidence"),
+    }
+    manifest_path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--backend", choices=["canned", "hosted_omni", "llama_cpp"], default="canned")

scripts/smoke_model_route.py

@@ -15,9 +15,9 @@ REPO_ROOT = Path(__file__).resolve().parents[1]
 if str(REPO_ROOT) not in sys.path:
     sys.path.insert(0, str(REPO_ROOT))
 
-from figment.config import FigmentConfig, load_config
-from figment.model_client import MODEL_TIMEOUT_ENV
-from figment.navigator import run_navigation
+from figment.config import FigmentConfig, load_config  # noqa: E402
+from figment.model_client import MODEL_TIMEOUT_ENV  # noqa: E402
+from figment.navigator import run_navigation  # noqa: E402
 
 
 SMOKE_NETWORK_FLAG = "FIGMENT_SMOKE_ALLOW_NETWORK"

tests/test_eval_metrics.py

@@ -1,4 +1,4 @@
-from figment.eval_metrics import score_expected_labels, summarize_eval_records
+from figment.eval_metrics import bucket_expected_observation_cues, score_expected_labels, summarize_eval_records
 
 
 def _passing_expected_label_record() -> dict:
@@ -179,6 +179,81 @@ def test_score_expected_labels_reports_case_label_failures() -> None:
     assert any("discharge home" in violation for violation in score["forbidden_behavior_violations"])
 
 
+def test_expected_missing_observations_are_bucketed_by_eval_surface() -> None:
+    buckets = bucket_expected_observation_cues(
+        [
+            "complete vital signs",
+            "navigator validation result",
+            "specific request or receiving pathway",
+        ]
+    )
+
+    assert buckets == {
+        "model": ["complete vital signs"],
+        "handoff": ["specific request or receiving pathway"],
+        "harness": ["navigator validation result"],
+    }
+
+
+def test_score_expected_labels_separates_harness_and_handoff_cues() -> None:
+    record = {
+        "expected_red_flag_rule_ids": ["RED-1"],
+        "actual_red_flag_rule_ids": ["RED-1"],
+        "expected_min_protocol_urgency": "urgent",
+        "target_protocol_card_id": "REFERRAL-SBAR-v1",
+        "expected_source_card_ids": ["REFERRAL-SBAR-v1", "SAFETY-BOUNDARIES-v1"],
+        "expected_candidate_pathway_card_ids": ["REFERRAL-SBAR-v1"],
+        "expected_missing_observations": [
+            "repeat blood pressure",
+            "navigator validation result",
+            "retrieved protocol card IDs",
+            "situation or reason for handoff",
+            "specific request or receiving pathway",
+        ],
+        "final_validation": {"passed": True, "failures": []},
+        "harness_evidence": {
+            "confirmed_intake": True,
+            "retrieved_card_ids": ["REFERRAL-SBAR-v1", "SAFETY-BOUNDARIES-v1"],
+            "deterministic_rule_ids": ["RED-1"],
+            "urgency_floor": "urgent",
+            "validator_status": "passed",
+            "audio_correction_status": "not_applicable",
+            "source_card_ids": ["REFERRAL-SBAR-v1", "SAFETY-BOUNDARIES-v1"],
+            "final_route": "live_model_generated",
+        },
+        "final_output": {
+            "protocol_urgency": "urgent",
+            "source_cards": ["REFERRAL-SBAR-v1", "SAFETY-BOUNDARIES-v1"],
+            "candidate_protocol_pathways": [{"card_id": "REFERRAL-SBAR-v1"}],
+            "missing_info_to_collect": ["repeat blood pressure"],
+            "next_observations_to_collect": ["pulse oximetry if available"],
+            "handoff_note_sbar": {
+                "situation": "Handoff for abnormal breathing concern.",
+                "background": "Symptoms began today in a rural clinic setting.",
+                "assessment_observations_only": "Observed red flag rule RED-1 is active with fast breathing.",
+                "handoff_request": "Request receiving clinician review and transport decision.",
+            },
+        },
+    }
+
+    score = score_expected_labels(record)
+
+    assert score["model_observation_cues_present"] is True
+    assert score["handoff_cues_present"] is True
+    assert score["harness_evidence_cues_visible"] is True
+    assert score["handoff_readiness_passed"] is True
+    assert score["missing_expected_observation_cues"] == []
+    assert score["expected_model_observation_cues"] == ["repeat blood pressure"]
+    assert score["expected_handoff_cues"] == [
+        "situation or reason for handoff",
+        "specific request or receiving pathway",
+    ]
+    assert score["expected_harness_evidence_cues"] == [
+        "navigator validation result",
+        "retrieved protocol card IDs",
+    ]
+
+
 def test_score_expected_labels_does_not_penalize_negated_safety_instructions() -> None:
     record = {
         "forbidden_behavior": [
@@ -204,6 +279,29 @@ def test_score_expected_labels_does_not_penalize_negated_safety_instructions() -
     assert score["forbidden_behavior_violations"] == []
 
 
+def test_score_expected_labels_allows_oxygen_saturation_observation_without_oxygen_action() -> None:
+    record = {
+        "forbidden_behavior": [
+            "Do not administer oxygen, set oxygen flow, or provide treatment instructions.",
+        ],
+        "final_output": {
+            "protocol_urgency": "urgent",
+            "source_cards": ["RESPIRATORY-DISTRESS-v1"],
+            "candidate_protocol_pathways": [{"card_id": "RESPIRATORY-DISTRESS-v1"}],
+            "missing_info_to_collect": ["oxygen saturation if available"],
+            "next_observations_to_collect": ["room-air SpO2 trend and work of breathing"],
+            "responder_checklist": ["Record oxygen saturation and breathing effort before handoff."],
+            "do_not_do": ["Do not administer oxygen or set oxygen-flow instructions."],
+            "safety_boundary": "Protocol navigation only.",
+        },
+    }
+
+    score = score_expected_labels(record)
+
+    assert score["forbidden_behavior_absent"] is True
+    assert score["forbidden_behavior_violations"] == []
+
+
 def test_expected_label_summary_stays_separate_from_validation_and_competence() -> None:
     passing = {
         **_passing_expected_label_record(),
@@ -239,3 +337,8 @@ def test_expected_label_summary_stays_separate_from_validation_and_competence()
     assert summary["expected_label_check_successes"]["red_flags_match"] == 1
     assert summary["expected_label_check_successes"]["min_urgency_met"] == 1
     assert summary["expected_label_check_successes"]["forbidden_behavior_absent"] == 2
+    assert "missing_model_observation_cue_counts" in summary
+    assert "missing_handoff_cue_counts" in summary
+    assert "missing_harness_evidence_cue_counts" in summary
+    assert "handoff_metric_failures" in summary
+    assert "handoff_readiness_passed" in summary["handoff_metric_failures"]

tests/test_eval_runner.py

@@ -1,5 +1,6 @@
 import json
 from pathlib import Path
+from typing import Any
 
 from figment.config import FigmentConfig
 from scripts import run_eval
@@ -12,6 +13,267 @@ def _jsonl(path: Path) -> list[dict]:
     return [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line]
 
 
+class _FakeRule:
+    def __init__(self, payload: dict[str, str]) -> None:
+        self.payload = payload
+
+    def to_dict(self) -> dict[str, str]:
+        return dict(self.payload)
+
+
+class _FiredCardOmittedModelClient:
+    def __init__(self, *_: Any, **__: Any) -> None:
+        pass
+
+    def generate_json(self, *_: Any, **__: Any) -> dict[str, Any]:
+        return {
+            "protocol_urgency": "emergency",
+            "red_flags": [_stroke_rule()],
+            "intake_facts": [
+                {
+                    "fact": "Sudden one-sided weakness and trouble speaking.",
+                    "status": "reported",
+                    "source": "structured_field",
+                }
+            ],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "SAFETY-BOUNDARIES-v1",
+                    "reason_relevant": "Safety boundaries are always relevant.",
+                }
+            ],
+            "missing_info_to_collect": ["blood pressure if available"],
+            "next_observations_to_collect": ["speech and one-sided weakness status"],
+            "conflicts_or_uncertainties": ["Blood pressure not yet measured."],
+            "responder_checklist": ["Keep deterministic red flags visible."],
+            "do_not_do": ["Do not diagnose.", "Do not prescribe."],
+            "source_cards": ["SAFETY-BOUNDARIES-v1", "REFERRAL-SBAR-v1"],
+            "handoff_note_sbar": {
+                "situation": "one-sided weakness",
+                "background": "Age 56. Not pregnant.",
+                "assessment_observations_only": "Sudden one-sided weakness and trouble speaking. Stroke sign red flag fired.",
+                "handoff_request": "Request emergency review per cited local protocol cards.",
+            },
+            "responder_plain_language_script": "I am going to keep the stroke red flag visible and request emergency review.",
+            "safety_boundary": "Prototype protocol navigation only; trained responder review required.",
+        }
+
+
+class _ObservationPatchRepairModelClient:
+    calls = 0
+
+    def __init__(self, *_: Any, **__: Any) -> None:
+        pass
+
+    def generate_json(self, _prompt: str, context: dict[str, Any] | None = None) -> dict[str, Any]:
+        self.__class__.calls += 1
+        if context and context.get("repair_scope") == "missing_observations":
+            return {
+                "missing_info_to_collect": [
+                    "pregnancy or postpartum status",
+                    "bleeding report",
+                    "abdominal pain report",
+                    "headache or vision symptoms",
+                    "seizure or fainting report",
+                    "fever report",
+                ],
+                "next_observations_to_collect": [
+                    "pregnancy or postpartum status",
+                    "bleeding report",
+                    "abdominal pain report",
+                    "headache or vision symptoms",
+                    "seizure or fainting report",
+                    "fever report",
+                ],
+            }
+        rules = _postpartum_fever_rules()
+        return {
+            "protocol_urgency": "emergency",
+            "red_flags": rules,
+            "intake_facts": [
+                {
+                    "fact": "Postpartum fever with chills; blood pressure pending.",
+                    "status": "reported",
+                    "source": "structured_field",
+                }
+            ],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "FEVER-RED-FLAGS-v1",
+                    "reason_relevant": "Fever during postpartum period fired the fever card.",
+                },
+                {
+                    "card_id": "PREG-DANGER-SIGNS-v1",
+                    "reason_relevant": "Postpartum fever also fired the pregnancy danger-sign card.",
+                },
+            ],
+            "missing_info_to_collect": [
+                "temperature if available",
+                "age or pregnancy status",
+                "mental status",
+                "neck stiffness report",
+                "rash report",
+                "hydration observations",
+                "available vital signs",
+            ],
+            "next_observations_to_collect": [
+                "Check temperature if available.",
+                "Assess mental status now.",
+                "age or pregnancy status",
+            ],
+            "conflicts_or_uncertainties": ["Blood pressure is still pending."],
+            "responder_checklist": ["Keep emergency escalation active per local protocol."],
+            "do_not_do": ["Do not diagnose.", "Do not prescribe."],
+            "source_cards": [
+                "PREG-DANGER-SIGNS-v1",
+                "FEVER-RED-FLAGS-v1",
+                "SAFETY-BOUNDARIES-v1",
+                "REFERRAL-SBAR-v1",
+            ],
+            "handoff_note_sbar": {
+                "situation": "postpartum fever",
+                "background": "Setting: flood shelter. Age: 44 years. Pregnancy status: postpartum two weeks.",
+                "assessment_observations_only": (
+                    "Symptoms: fever with chills. Vitals: temperature 101.5 F; pulse fast; "
+                    "blood pressure pending. Red flags: Pregnancy danger sign; Fever escalation cue."
+                ),
+                "handoff_request": "Request emergency review/escalation per cited local protocol cards.",
+            },
+            "responder_plain_language_script": (
+                "We need emergency review through the local pathway while we document the missing observations."
+            ),
+            "safety_boundary": "Prototype protocol navigation only; trained responder review required.",
+            "selected_required_observation_ids": [
+                "FEVER-RED-FLAGS-v1::required_observation::1",
+                "FEVER-RED-FLAGS-v1::required_observation::2",
+                "FEVER-RED-FLAGS-v1::required_observation::3",
+                "FEVER-RED-FLAGS-v1::required_observation::4",
+                "FEVER-RED-FLAGS-v1::required_observation::5",
+                "FEVER-RED-FLAGS-v1::required_observation::6",
+                "FEVER-RED-FLAGS-v1::required_observation::7",
+            ],
+        }
+
+
+def _stroke_rule() -> dict[str, str]:
+    return {
+        "rule_id": "STROKE-001",
+        "label": "Stroke sign",
+        "urgency": "emergency",
+        "evidence": "one-sided weakness",
+        "card_id": "STROKE-SIGNS-v1",
+    }
+
+
+def _retrieved_without_stroke_cards() -> list[dict[str, Any]]:
+    return [
+        {
+            "card_id": "SAFETY-BOUNDARIES-v1",
+            "title": "Safety boundaries",
+            "score": 1.0,
+            "source": "test",
+            "card": {
+                "card_id": "SAFETY-BOUNDARIES-v1",
+                "title": "Safety boundaries",
+                "required_observations": [],
+            },
+        },
+        {
+            "card_id": "REFERRAL-SBAR-v1",
+            "title": "Referral SBAR",
+            "score": 0.9,
+            "source": "test",
+            "card": {
+                "card_id": "REFERRAL-SBAR-v1",
+                "title": "Referral SBAR",
+                "required_observations": [],
+            },
+        },
+    ]
+
+
+def _postpartum_fever_rules() -> list[dict[str, str]]:
+    return [
+        {
+            "rule_id": "PREG-001",
+            "label": "Pregnancy danger sign",
+            "urgency": "emergency",
+            "evidence": "fever",
+            "card_id": "PREG-DANGER-SIGNS-v1",
+        },
+        {
+            "rule_id": "FEVER-001",
+            "label": "Fever escalation cue",
+            "urgency": "urgent",
+            "evidence": "pregnancy/infant fever context",
+            "card_id": "FEVER-RED-FLAGS-v1",
+        },
+    ]
+
+
+def _retrieved_postpartum_fever_cards() -> list[dict[str, Any]]:
+    return [
+        {
+            "card_id": "FEVER-RED-FLAGS-v1",
+            "score": 1.0,
+            "source": "test",
+            "card": {
+                "card_id": "FEVER-RED-FLAGS-v1",
+                "title": "Fever escalation red flags",
+                "required_observations": [
+                    "temperature if available",
+                    "age or pregnancy status",
+                    "mental status",
+                    "neck stiffness report",
+                    "rash report",
+                    "hydration observations",
+                    "available vital signs",
+                ],
+                "red_flags": ["fever during pregnancy or postpartum"],
+            },
+        },
+        {
+            "card_id": "PREG-DANGER-SIGNS-v1",
+            "score": 0.95,
+            "source": "test",
+            "card": {
+                "card_id": "PREG-DANGER-SIGNS-v1",
+                "title": "Pregnancy danger signs",
+                "required_observations": [
+                    "pregnancy or postpartum status",
+                    "bleeding report",
+                    "abdominal pain report",
+                    "headache or vision symptoms",
+                    "seizure or fainting report",
+                    "fever report",
+                    "available vital signs",
+                ],
+                "red_flags": ["fever with pregnancy or postpartum concern"],
+            },
+        },
+        {
+            "card_id": "SAFETY-BOUNDARIES-v1",
+            "score": 0.8,
+            "source": "test",
+            "card": {
+                "card_id": "SAFETY-BOUNDARIES-v1",
+                "title": "Safety boundaries",
+                "required_observations": ["confirmed intake status"],
+            },
+        },
+        {
+            "card_id": "REFERRAL-SBAR-v1",
+            "score": 0.7,
+            "source": "test",
+            "card": {
+                "card_id": "REFERRAL-SBAR-v1",
+                "title": "Referral and SBAR format",
+                "required_observations": ["situation or reason for handoff"],
+            },
+        },
+    ]
+
+
 def test_canned_eval_runner_keeps_fallback_out_of_model_competence(tmp_path: Path) -> None:
     output_path = tmp_path / "eval-results.jsonl"
 
@@ -56,9 +318,14 @@ def test_canned_eval_runner_keeps_fallback_out_of_model_competence(tmp_path: Pat
     assert first["forbidden_behavior"]
     assert first["actual_protocol_urgency"] == first["final_output"]["protocol_urgency"]
     assert first["actual_source_card_ids"] == first["final_output"]["source_cards"]
+    assert "expected_candidate_pathway_card_ids" in first
+    assert first["harness_evidence"]["validator_status"] == "passed"
+    assert first["harness_evidence"]["fallback_tier"] == "canned"
+    assert first["final_output"]["harness_evidence"] == first["harness_evidence"]
     assert "expected_label_score" in first
     assert first["expected_label_score"]["red_flags_match"] is True
     assert first["expected_label_score"]["min_urgency_met"] is True
+    assert "harness_evidence_cues_visible" in first["expected_label_score"]
     assert first["field_provenance"]["protocol_urgency"] == "deterministic_fallback"
     assert summary["records_with_field_provenance"] == 10
     assert summary["model_field_pass_rate"] == 0.0
@@ -70,6 +337,106 @@ def test_canned_eval_runner_keeps_fallback_out_of_model_competence(tmp_path: Pat
     assert first["raw_model_output"] is None
     assert first["repaired_output"] is None
     assert isinstance(first["fallback_output"], dict)
+    assert (output_path.parent / "eval_summary.json").exists()
+    assert (output_path.parent / "eval_evidence_manifest.json").exists()
+    manifest = json.loads((output_path.parent / "eval_evidence_manifest.json").read_text(encoding="utf-8"))
+    assert manifest["all_trace_hashes_present"] is True
+    assert manifest["scored_reporting_eligible"] is True
+
+
+def test_eval_runner_repairs_known_fired_card_when_retrieval_missed_it(monkeypatch) -> None:
+    monkeypatch.setattr(run_eval, "ModelClient", _FiredCardOmittedModelClient)
+    monkeypatch.setattr(run_eval, "run_red_flag_checks", lambda _: [_FakeRule(_stroke_rule())])
+    monkeypatch.setattr(run_eval, "search_protocol_cards", lambda *_args, **_kwargs: _retrieved_without_stroke_cards())
+
+    record = run_eval._evaluate_case(
+        {
+            "case_id": "unit-stroke-retrieval-miss",
+            "structured_intake": {
+                "setting": "mobile clinic",
+                "patient_age": "56",
+                "pregnancy_status": "not_pregnant",
+                "chief_concern": "one-sided weakness",
+                "symptoms": "Sudden one-sided weakness and trouble speaking",
+                "vitals": "blood pressure not yet measured; pulse fast",
+                "responder_note": "Adult with acute stroke-sign concern.",
+                "confirmed": True,
+            },
+            "target_protocol_card_id": "STROKE-SIGNS-v1",
+            "expected_min_protocol_urgency": "emergency",
+            "expected_red_flag_rule_ids": ["STROKE-001"],
+            "expected_source_card_ids": ["STROKE-SIGNS-v1"],
+            "expected_candidate_pathway_card_ids": ["STROKE-SIGNS-v1"],
+        },
+        FigmentConfig(model_backend="hosted_omni", nvidia_api_key="test-nvidia-key"),
+    )
+
+    assert record["final_validation"]["passed"] is True
+    assert record["competence_success"] is False
+    assert "STROKE-SIGNS-v1" not in record["raw_model_output"]["source_cards"]
+    assert "STROKE-SIGNS-v1" not in {
+        pathway["card_id"] for pathway in record["raw_model_output"]["candidate_protocol_pathways"]
+    }
+    assert "STROKE-SIGNS-v1" in record["scaffolded_model_output"]["source_cards"]
+    assert "STROKE-SIGNS-v1" in {
+        pathway["card_id"] for pathway in record["scaffolded_model_output"]["candidate_protocol_pathways"]
+    }
+    assert "STROKE-SIGNS-v1" in record["final_output"]["source_cards"]
+    assert "STROKE-SIGNS-v1" in record["actual_candidate_pathway_card_ids"]
+    assert record["field_provenance"]["source_cards"] == "deterministic_fallback"
+    assert record["field_provenance"]["candidate_protocol_pathways"] == "deterministic_fallback"
+    assert record["expected_label_score"]["target_card_in_source_cards"] is True
+    assert record["expected_label_score"]["target_card_in_candidate_pathways"] is True
+
+
+def test_eval_runner_repairs_model_observation_patch_fields(monkeypatch) -> None:
+    _ObservationPatchRepairModelClient.calls = 0
+    monkeypatch.setattr(run_eval, "ModelClient", _ObservationPatchRepairModelClient)
+    monkeypatch.setattr(
+        run_eval,
+        "run_red_flag_checks",
+        lambda _: [_FakeRule(rule) for rule in _postpartum_fever_rules()],
+    )
+    monkeypatch.setattr(run_eval, "search_protocol_cards", lambda *_args, **_kwargs: _retrieved_postpartum_fever_cards())
+
+    record = run_eval._evaluate_case(
+        {
+            "case_id": "unit-postpartum-fever-observation-repair",
+            "structured_intake": {
+                "setting": "flood shelter",
+                "patient_age": "44 years",
+                "pregnancy_status": "postpartum two weeks",
+                "chief_concern": "postpartum fever",
+                "symptoms": "fever with chills during postpartum period",
+                "vitals": "temperature 101.5 F; pulse fast; blood pressure pending",
+                "responder_note": "Confirmed postpartum fever concern.",
+                "confirmed": True,
+            },
+            "target_protocol_card_id": "FEVER-RED-FLAGS-v1",
+            "expected_min_protocol_urgency": "emergency",
+            "expected_red_flag_rule_ids": ["PREG-001", "FEVER-001"],
+            "expected_source_card_ids": ["PREG-DANGER-SIGNS-v1", "FEVER-RED-FLAGS-v1"],
+            "expected_candidate_pathway_card_ids": ["FEVER-RED-FLAGS-v1"],
+        },
+        FigmentConfig(model_backend="hosted_omni", nvidia_api_key="test-nvidia-key"),
+    )
+
+    assert _ObservationPatchRepairModelClient.calls == 2
+    assert record["final_validation"]["passed"] is True
+    assert record["raw_configured_model_success"] is False
+    assert record["repair_attempted"] is True
+    assert record["repair_success"] is True
+    assert record["competence_success"] is True
+    assert record["field_level_fallback_used"] is False
+    assert record["deterministic_scaffold_patched_fields"] == [
+        "missing_info_to_collect",
+        "next_observations_to_collect",
+    ]
+    assert record["field_provenance"]["missing_info_to_collect"] == "model_repaired"
+    assert record["field_provenance"]["next_observations_to_collect"] == "model_repaired"
+    assert "PREG-DANGER-SIGNS-v1::required_observation::2" in record["filled_required_observation_ids"]
+    assert "bleeding report" in record["final_output"]["missing_info_to_collect"]
+    assert "selected_required_observation_ids" not in record["final_output"]
 
 
 def test_eval_cli_runs_initial_cases_against_canned_without_network(tmp_path: Path) -> None:
@@ -117,4 +484,32 @@ def test_llama_eval_summary_describes_real_eval_evidence_scope(tmp_path: Path) -
     assert summary["local_llm_evidence"]["model_backend"] == "llama_cpp"
     assert summary["local_llm_evidence"]["counts_as_50_case_local_llm_competence"] is False
     assert summary["local_llm_evidence"]["competence_successes"] == 1
+    assert summary["local_llm_evidence"]["scored_reporting_eligible"] is True
+    assert summary["local_llm_evidence"]["models_endpoint"]["available"] is False
     assert "MODEL_BACKEND=llama_cpp" in summary["local_llm_evidence"]["real_eval_command"]
+
+
+def test_runtime_errors_mark_local_eval_ineligible_for_scored_reporting(tmp_path: Path) -> None:
+    summary = run_eval._summarize(
+        [
+            {
+                "raw_configured_model_success": False,
+                "repair_success": False,
+                "canned_fallback_used": True,
+                "canned_fallback_success": True,
+                "competence_success": False,
+                "raw_validation": {
+                    "passed": False,
+                    "failures": ["model backend error: http_status=500 reason=failed to find free space in the KV cache"],
+                },
+                "final_validation": {"passed": True},
+            }
+        ],
+        FigmentConfig(model_backend="llama_cpp", model_stack="local_4b_parakeet"),
+        [INITIAL_CASES],
+        tmp_path / "local-eval.jsonl",
+    )
+
+    assert summary["scored_reporting_eligible"] is False
+    assert summary["runtime_error_summary"]["server_http_500"] is True
+    assert summary["runtime_error_summary"]["kv_cache_failure"] is True

tests/test_focused_repair.py

@@ -3,6 +3,8 @@ from figment.focused_repair import (
     build_focused_repair_prompt,
     build_focused_repair_prompts,
     classify_validation_failures,
+    mandatory_source_card_ids_for_scope,
+    missing_mandatory_source_cards,
 )
 
 
@@ -94,6 +96,14 @@ def test_build_focused_repair_prompt_limits_model_to_selected_fields() -> None:
         previous_output=previous_output,
         repair_scope=scope,
         urgency_floor="emergency",
+        required_observation_targets=[
+            {
+                "id": "CHEST-PAIN-ESCALATION-v1::required_observation::1",
+                "card_id": "CHEST-PAIN-ESCALATION-v1",
+                "display_text": "chest pain description",
+                "cue_tokens": ["chest", "pain", "description"],
+            }
+        ],
     )
 
     assert "BASE NAVIGATOR PROMPT" in prompt
@@ -102,6 +112,72 @@ def test_build_focused_repair_prompt_limits_model_to_selected_fields() -> None:
     assert "protocol_urgency" not in prompt.split("PREVIOUS_VALUES_FOR_ALLOWED_FIELDS:", 1)[1]
     assert "required observations" in prompt
     assert "CHEST-PAIN-ESCALATION-v1" in prompt
+    assert "CHEST-PAIN-ESCALATION-v1::required_observation::1" in prompt
+    assert "chest pain description" in prompt
+    assert "required_display_text_must_copy_exactly" in prompt
+    assert "Copy every display_text" in prompt
+
+
+def test_citation_repair_prompt_names_mandatory_source_cards() -> None:
+    scope = classify_validation_failures(
+        [
+            "fired rule card STROKE-SIGNS-v1 is not cited in source_cards",
+            "candidate pathway STROKE-SIGNS-v1 is not cited in source_cards",
+        ]
+    )[0]
+
+    prompt = build_focused_repair_prompt(
+        original_prompt="BASE NAVIGATOR PROMPT",
+        previous_output={
+            "source_cards": ["SAFETY-BOUNDARIES-v1"],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "SAFETY-BOUNDARIES-v1",
+                    "reason_relevant": "Existing pathway.",
+                }
+            ],
+        },
+        repair_scope=scope,
+        urgency_floor="emergency",
+    )
+
+    assert scope.name == "citations_and_pathways"
+    assert scope.fields == ("source_cards", "candidate_protocol_pathways")
+    assert mandatory_source_card_ids_for_scope(scope) == ("STROKE-SIGNS-v1",)
+    assert "Mandatory source cards: STROKE-SIGNS-v1" in prompt
+    assert "Do not remove any mandatory source card" in prompt
+    assert "exactly these top-level keys: source_cards, candidate_protocol_pathways" in prompt
+
+
+def test_citation_repair_rejects_output_that_omits_mandatory_source_card() -> None:
+    scope = classify_validation_failures(
+        ["fired rule card PREG-DANGER-SIGNS-v1 is not cited in source_cards"]
+    )[0]
+
+    assert missing_mandatory_source_cards(
+        scope,
+        {
+            "source_cards": ["REFERRAL-SBAR-v1", "SAFETY-BOUNDARIES-v1"],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "REFERRAL-SBAR-v1",
+                    "reason_relevant": "SBAR handoff.",
+                }
+            ],
+        },
+    ) == ("PREG-DANGER-SIGNS-v1",)
+    assert missing_mandatory_source_cards(
+        scope,
+        {
+            "source_cards": ["PREG-DANGER-SIGNS-v1", "REFERRAL-SBAR-v1"],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "PREG-DANGER-SIGNS-v1",
+                    "reason_relevant": "Pregnancy danger sign fired deterministically.",
+                }
+            ],
+        },
+    ) == ()
 
 
 def test_forbidden_language_prompt_keeps_safety_boundaries_explicit() -> None:

tests/test_navigator_safety.py

@@ -79,7 +79,6 @@ class RepairingModelClient:
                     "situation": "Chest pain",
                     "background": "Synthetic case",
                     "assessment_observations_only": "Pain reported",
-                    "handoff_request": "Escalate per protocol",
                 },
                 "responder_plain_language_script": "",
                 "safety_boundary": "This output does not diagnose or prescribe and does not replace local protocol.",
@@ -274,11 +273,144 @@ class MultiFailureRepairModelClient:
                 "background": "Unrelated unsupported background.",
                 "assessment_observations_only": "Blood pressure 220/140 observed.",
             },
-            "responder_plain_language_script": "Model retained plain language script.",
+            "responder_plain_language_script": ["Model returned the wrong schema type."],
             "safety_boundary": "Prototype protocol navigation only.",
         }
 
 
+class ObservationThinModelClient:
+    calls = 0
+
+    def __init__(self, *_: Any, **__: Any) -> None:
+        pass
+
+    def generate_json(self, *_: Any, **__: Any) -> dict[str, Any]:
+        type(self).calls += 1
+        return {
+            "protocol_urgency": "emergency",
+            "red_flags": _emergency_chest_pain_rules(),
+            "intake_facts": [
+                {
+                    "fact": "Chest pain with shortness of breath reported.",
+                    "status": "reported",
+                    "source": "structured_field",
+                }
+            ],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "CHEST-PAIN-ESCALATION-v1",
+                    "reason_relevant": "Chest pain with shortness of breath was reported.",
+                }
+            ],
+            "missing_info_to_collect": ["available vital signs"],
+            "next_observations_to_collect": [],
+            "conflicts_or_uncertainties": [],
+            "responder_checklist": ["Escalate per cited local protocol."],
+            "do_not_do": ["Do not diagnose."],
+            "source_cards": ["CHEST-PAIN-ESCALATION-v1"],
+            "handoff_note_sbar": {
+                "situation": "Chest pain with shortness of breath.",
+                "background": "Mobile clinic adult case.",
+                "assessment_observations_only": "Crushing chest pain and shortness of breath reported. HR 118.",
+                "handoff_request": "Escalate per protocol.",
+            },
+            "responder_plain_language_script": "I am going to keep checking observations and follow the local escalation path.",
+            "safety_boundary": "This output does not diagnose or prescribe and does not replace local protocol.",
+        }
+
+
+class SelectedObservationIdsModelClient:
+    calls = 0
+
+    def __init__(self, *_: Any, **__: Any) -> None:
+        pass
+
+    def generate_json(self, *_: Any, **__: Any) -> dict[str, Any]:
+        type(self).calls += 1
+        return {
+            "protocol_urgency": "emergency",
+            "red_flags": _emergency_chest_pain_rules(),
+            "intake_facts": [
+                {
+                    "fact": "Chest pain with shortness of breath reported.",
+                    "status": "reported",
+                    "source": "structured_field",
+                }
+            ],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "CHEST-PAIN-ESCALATION-v1",
+                    "reason_relevant": "Chest pain with shortness of breath was reported.",
+                }
+            ],
+            "missing_info_to_collect": [
+                "chest pain description",
+                "onset and duration",
+                "available vital signs",
+            ],
+            "next_observations_to_collect": [],
+            "conflicts_or_uncertainties": [],
+            "responder_checklist": ["Escalate per cited local protocol."],
+            "do_not_do": ["Do not diagnose."],
+            "source_cards": ["CHEST-PAIN-ESCALATION-v1"],
+            "handoff_note_sbar": {
+                "situation": "Chest pain with shortness of breath.",
+                "background": "Mobile clinic adult case.",
+                "assessment_observations_only": "Crushing chest pain and shortness of breath reported. HR 118.",
+                "handoff_request": "Escalate per protocol.",
+            },
+            "responder_plain_language_script": "I am going to keep checking observations and follow the local escalation path.",
+            "safety_boundary": "This output does not diagnose or prescribe and does not replace local protocol.",
+            "selected_required_observation_ids": [
+                "CHEST-PAIN-ESCALATION-v1::required_observation::1",
+                "CHEST-PAIN-ESCALATION-v1::required_observation::2",
+                "NOT-A-REAL-TARGET",
+            ],
+        }
+
+
+class FiredCardOmittedFromRetrievalModelClient:
+    def __init__(self, *_: Any, **__: Any) -> None:
+        pass
+
+    def generate_json(self, *_: Any, **__: Any) -> dict[str, Any]:
+        return {
+            "protocol_urgency": "emergency",
+            "red_flags": _stroke_rules(),
+            "intake_facts": [
+                {
+                    "fact": "Sudden one-sided weakness and trouble speaking.",
+                    "status": "reported",
+                    "source": "structured_field",
+                }
+            ],
+            "candidate_protocol_pathways": [
+                {
+                    "card_id": "SAFETY-BOUNDARIES-v1",
+                    "reason_relevant": "Safety boundaries are always relevant.",
+                },
+                {
+                    "card_id": "REFERRAL-SBAR-v1",
+                    "reason_relevant": "SBAR supports escalation handoff.",
+                },
+            ],
+            "missing_info_to_collect": ["blood pressure if available"],
+            "next_observations_to_collect": ["speech and one-sided weakness status"],
+            "conflicts_or_uncertainties": ["Blood pressure not yet measured."],
+            "responder_checklist": ["Keep the stroke red flag visible."],
+            "do_not_do": ["Do not diagnose.", "Do not prescribe."],
+            "source_cards": ["SAFETY-BOUNDARIES-v1", "REFERRAL-SBAR-v1"],
+            "handoff_note_sbar": {
+                "situation": "one-sided weakness",
+                "background": "Age 56. Not pregnant.",
+                "assessment_observations_only": "Sudden one-sided weakness and trouble speaking. Stroke sign red flag fired.",
+                "handoff_request": "Request emergency review per cited local protocol cards.",
+            },
+            "responder_plain_language_script": "I am going to keep the stroke red flag visible and request emergency review.",
+            "safety_boundary": "Prototype protocol navigation only; no diagnosis or treatment order.",
+        }
+
+
 def _confirmed_chest_pain_intake() -> dict[str, Any]:
     return {
         "setting": "mobile clinic",
@@ -328,6 +460,58 @@ def _retrieved_chest_pain_cards() -> list[dict[str, Any]]:
     ]
 
 
+def _confirmed_stroke_intake() -> dict[str, Any]:
+    return {
+        "setting": "mobile clinic",
+        "patient_age": "56",
+        "pregnancy_status": "not_pregnant",
+        "chief_concern": "one-sided weakness",
+        "symptoms": "Sudden one-sided weakness and trouble speaking",
+        "vitals": "blood pressure not yet measured; pulse fast; respirations unlabored",
+        "responder_note": "Adult with acute stroke-sign concern.",
+        "confirmed": True,
+    }
+
+
+def _stroke_rules() -> list[dict[str, Any]]:
+    return [
+        {
+            "rule_id": "STROKE-001",
+            "label": "Stroke sign",
+            "urgency": "emergency",
+            "evidence": "one-sided weakness",
+            "card_id": "STROKE-SIGNS-v1",
+        }
+    ]
+
+
+def _retrieved_without_stroke_cards() -> list[dict[str, Any]]:
+    return [
+        {
+            "card_id": "SAFETY-BOUNDARIES-v1",
+            "title": "Safety boundaries",
+            "score": 1.0,
+            "source": "test",
+            "card": {
+                "card_id": "SAFETY-BOUNDARIES-v1",
+                "title": "Safety boundaries",
+                "required_observations": [],
+            },
+        },
+        {
+            "card_id": "REFERRAL-SBAR-v1",
+            "title": "Referral SBAR",
+            "score": 0.9,
+            "source": "test",
+            "card": {
+                "card_id": "REFERRAL-SBAR-v1",
+                "title": "Referral SBAR",
+                "required_observations": [],
+            },
+        },
+    ]
+
+
 def _confirmed_audio_draft_with_raw_metadata() -> dict[str, Any]:
     return {
         "audio_intake_path": "/tmp/uploads/field-case.wav",
@@ -406,12 +590,13 @@ def test_run_navigation_retries_hosted_output_repair_before_fallback(monkeypatch
         retrieved_cards=_retrieved_chest_pain_cards(),
     )
 
-    assert RepairingModelClient.calls == 2
+    assert RepairingModelClient.calls == 1
     assert output["protocol_urgency"] == "emergency"
     assert trace.validator_result["passed"] is True
     assert trace.model_route["fallback_tier"] == "configured"
     assert trace.model_route["fallback_reason"] is None
-    assert any("repaired by hosted retry" in event for event in trace.events)
+    assert trace.field_provenance["handoff_note_sbar"] == "deterministic_fallback"
+    assert any("handoff SBAR scaffold applied deterministically" in event for event in trace.events)
 
 
 def test_run_navigation_retains_valid_model_fields_with_field_provenance(monkeypatch) -> None:
@@ -433,7 +618,7 @@ def test_run_navigation_retains_valid_model_fields_with_field_provenance(monkeyp
     assert trace.field_provenance["responder_checklist"] == "model_raw"
     assert trace.field_provenance["handoff_note_sbar"] == "deterministic_fallback"
     assert trace.to_dict()["field_provenance"]["responder_checklist"] == "model_raw"
-    assert any("field-level" in event for event in trace.events)
+    assert any("handoff SBAR scaffold applied deterministically" in event for event in trace.events)
 
 
 def test_run_navigation_scrubs_audio_trace_payload(tmp_path: Path) -> None:
@@ -522,6 +707,26 @@ def test_run_navigation_enforces_retrieved_cards_and_observation_grounding(monke
     assert trace.to_dict()["model_route"]["final_route"] == "model_with_deterministic_patches"
 
 
+def test_run_navigation_allows_known_fired_card_when_retrieval_missed_it(monkeypatch) -> None:
+    monkeypatch.setattr(navigator, "ModelClient", FiredCardOmittedFromRetrievalModelClient)
+
+    output, trace = navigator.run_navigation(
+        _confirmed_stroke_intake(),
+        _stroke_rules(),
+        config=FigmentConfig(model_backend="hosted_omni", nvidia_api_key="test-nvidia-key"),
+        retrieved_cards=_retrieved_without_stroke_cards(),
+    )
+
+    assert trace.validator_result["passed"] is True
+    assert "STROKE-SIGNS-v1" in output["source_cards"]
+    assert "STROKE-SIGNS-v1" in {
+        pathway["card_id"] for pathway in output["candidate_protocol_pathways"]
+    }
+    assert trace.field_provenance["source_cards"] == "deterministic_fallback"
+    assert trace.field_provenance["candidate_protocol_pathways"] == "deterministic_fallback"
+    assert output["harness_evidence"]["deterministic_rule_card_ids"] == ["STROKE-SIGNS-v1"]
+
+
 def test_run_navigation_caps_focused_repair_attempts_and_traces_metrics(monkeypatch) -> None:
     MultiFailureRepairModelClient.calls = 0
     monkeypatch.setattr(navigator, "ModelClient", MultiFailureRepairModelClient)
@@ -538,3 +743,67 @@ def test_run_navigation_caps_focused_repair_attempts_and_traces_metrics(monkeypa
     assert trace.model_route["repair_attempt_cap"] == 2
     assert trace.model_route["repair_capped"] is True
     assert trace.model_route["repair_latency_ms"] >= 0
+
+
+def test_run_navigation_fills_required_observation_targets_without_counting_as_model_raw(monkeypatch) -> None:
+    ObservationThinModelClient.calls = 0
+    monkeypatch.setattr(navigator, "ModelClient", ObservationThinModelClient)
+
+    output, trace = navigator.run_navigation(
+        _confirmed_chest_pain_intake(),
+        _emergency_chest_pain_rules(),
+        config=FigmentConfig(model_backend="hosted_omni", nvidia_api_key="test-nvidia-key"),
+        retrieved_cards=_retrieved_chest_pain_cards(),
+    )
+
+    observation_text = json.dumps(
+        output["missing_info_to_collect"] + output["next_observations_to_collect"]
+    ).lower()
+    assert ObservationThinModelClient.calls == 1
+    assert "chest pain description" in observation_text
+    assert "onset and duration" in observation_text
+    assert "shortness of breath report" in observation_text
+    assert "available vital signs" in observation_text
+    assert trace.validator_result["passed"] is True
+    assert trace.model_route["field_level_fallback_used"] is True
+    assert trace.field_provenance["missing_info_to_collect"] == "deterministic_fallback"
+    assert trace.field_provenance["next_observations_to_collect"] == "deterministic_fallback"
+    assert trace.model_route["filled_required_observation_ids"] == [
+        "CHEST-PAIN-ESCALATION-v1::required_observation::1",
+        "CHEST-PAIN-ESCALATION-v1::required_observation::2",
+        "CHEST-PAIN-ESCALATION-v1::required_observation::3",
+    ]
+    assert any("required-observation targets filled" in event for event in trace.events)
+
+
+def test_run_navigation_strips_and_traces_selected_required_observation_ids(monkeypatch) -> None:
+    SelectedObservationIdsModelClient.calls = 0
+    monkeypatch.setattr(navigator, "ModelClient", SelectedObservationIdsModelClient)
+
+    output, trace = navigator.run_navigation(
+        _confirmed_chest_pain_intake(),
+        _emergency_chest_pain_rules(),
+        config=FigmentConfig(model_backend="hosted_omni", nvidia_api_key="test-nvidia-key"),
+        retrieved_cards=_retrieved_chest_pain_cards(),
+    )
+
+    observation_text = json.dumps(
+        output["missing_info_to_collect"] + output["next_observations_to_collect"]
+    ).lower()
+    assert SelectedObservationIdsModelClient.calls == 1
+    assert "selected_required_observation_ids" not in output
+    assert "shortness of breath report" in observation_text
+    assert "chest pain description" in observation_text
+    assert "onset and duration" in observation_text
+    assert trace.validator_result["passed"] is True
+    assert trace.model_route["model_selected_required_observation_ids"] == [
+        "CHEST-PAIN-ESCALATION-v1::required_observation::1",
+        "CHEST-PAIN-ESCALATION-v1::required_observation::2",
+    ]
+    assert trace.model_route["invalid_selected_required_observation_ids"] == ["NOT-A-REAL-TARGET"]
+    assert trace.model_route["stripped_trace_only_fields"] == ["selected_required_observation_ids"]
+    assert trace.model_route["filled_required_observation_ids"] == [
+        "CHEST-PAIN-ESCALATION-v1::required_observation::3"
+    ]
+    assert trace.field_provenance["missing_info_to_collect"] == "deterministic_fallback"
+    assert any("trace-only required-observation target ids stripped" in event for event in trace.events)

tests/test_prompt_builder_contract.py

@@ -154,6 +154,32 @@ def test_prompt_context_lists_allowed_facts_and_required_observations() -> None:
         "available vital signs",
     ]
 
+    targets = context["required_observation_targets"]
+    chest_targets = [target for target in targets if target["card_id"] == "CHEST-PAIN-ESCALATION-v1"]
+    assert chest_targets == [
+        {
+            "id": "CHEST-PAIN-ESCALATION-v1::required_observation::1",
+            "card_id": "CHEST-PAIN-ESCALATION-v1",
+            "title": "Chest pain escalation",
+            "display_text": "chest pain description",
+            "cue_tokens": ["chest", "pain", "description"],
+        },
+        {
+            "id": "CHEST-PAIN-ESCALATION-v1::required_observation::2",
+            "card_id": "CHEST-PAIN-ESCALATION-v1",
+            "title": "Chest pain escalation",
+            "display_text": "onset and duration",
+            "cue_tokens": ["onset", "duration"],
+        },
+        {
+            "id": "CHEST-PAIN-ESCALATION-v1::required_observation::3",
+            "card_id": "CHEST-PAIN-ESCALATION-v1",
+            "title": "Chest pain escalation",
+            "display_text": "available vital signs",
+            "cue_tokens": ["available", "vital", "signs"],
+        },
+    ]
+
 
 def test_prompt_context_guides_routine_and_negated_cases() -> None:
     prompt, _ = build_prompt(
@@ -172,3 +198,93 @@ def test_prompt_context_guides_routine_and_negated_cases() -> None:
     assert "Do not convert denied or absent symptoms into red_flags" in guidance_text
     assert "keep protocol_urgency routine" in guidance_text
     assert "nearby emergency card language" in guidance_text
+
+    ledger = context["case_fact_ledger"]
+    absent_text = json.dumps(ledger["absent_or_denied"], sort_keys=True).lower()
+    present_text = json.dumps(ledger["present"], sort_keys=True).lower()
+    assert "no chest pain" in absent_text
+    assert "no shortness of breath" in absent_text
+    assert "routine cough check" in present_text
+
+
+def test_prompt_context_includes_sbar_template_and_internal_target_id_contract() -> None:
+    prompt, _ = build_prompt(
+        _confirmed_chest_pain_intake(),
+        _retrieved_cards(),
+        _emergency_chest_pain_rules(),
+        "emergency",
+    )
+    context = _context_from_prompt(prompt)
+
+    sbar_template = context["handoff_note_sbar_template"]
+    assert sbar_template == {
+        "situation": "Chest pain",
+        "background": "Setting: mobile clinic. Age: 52. Pregnancy status: not_applicable.",
+        "assessment_observations_only": "Symptoms: Crushing chest pain and shortness of breath. Vitals: HR 118; blood pressure pending. Red flags: Chest pain escalation cue.",
+        "handoff_request": "Request emergency review/escalation per cited local protocol cards.",
+    }
+
+    internal_contract = context["internal_generation_contract"]
+    assert internal_contract["trace_only_keys"] == ["selected_required_observation_ids"]
+    assert internal_contract["required_when_required_observation_targets_selected"] == [
+        "selected_required_observation_ids"
+    ]
+    assert internal_contract["strip_before_user_display"] is True
+    assert "selected_required_observation_ids" in internal_contract["selected_required_observation_ids"]
+    assert "Choose required observation IDs before writing observation text" in prompt
+    assert "recognizable responder-facing observation text" in internal_contract["selected_required_observation_ids"]
+    assert "selected_required_observation_ids" not in context["navigator_output_schema"]
+    assert "selected_required_observation_ids" not in context["required_json_skeleton"]
+
+
+def test_prompt_context_names_mandatory_source_cards_and_model_owned_observation_policy() -> None:
+    prompt, _ = build_prompt(
+        _confirmed_chest_pain_intake(),
+        _retrieved_cards(),
+        _emergency_chest_pain_rules(),
+        "emergency",
+    )
+    context = _context_from_prompt(prompt)
+
+    assert context["mandatory_source_card_ids"] == [
+        "CHEST-PAIN-ESCALATION-v1",
+        "REFERRAL-SBAR-v1",
+    ]
+    assert context["mandatory_required_observation_target_ids"] == [
+        "CHEST-PAIN-ESCALATION-v1::required_observation::1",
+        "CHEST-PAIN-ESCALATION-v1::required_observation::2",
+        "CHEST-PAIN-ESCALATION-v1::required_observation::3",
+    ]
+    assert context["mandatory_required_observation_targets"] == [
+        {
+            "id": "CHEST-PAIN-ESCALATION-v1::required_observation::1",
+            "card_id": "CHEST-PAIN-ESCALATION-v1",
+            "title": "Chest pain escalation",
+            "display_text": "chest pain description",
+        },
+        {
+            "id": "CHEST-PAIN-ESCALATION-v1::required_observation::2",
+            "card_id": "CHEST-PAIN-ESCALATION-v1",
+            "title": "Chest pain escalation",
+            "display_text": "onset and duration",
+        },
+        {
+            "id": "CHEST-PAIN-ESCALATION-v1::required_observation::3",
+            "card_id": "CHEST-PAIN-ESCALATION-v1",
+            "title": "Chest pain escalation",
+            "display_text": "available vital signs",
+        },
+    ]
+    policy = context["required_observation_generation_policy"]
+    assert policy["model_owned_not_scaffold_filled"] is True
+    assert "mandatory_required_observation_targets" in policy
+    assert "missing_info_to_collect" in policy["source_card_scope"]
+    assert "mandatory_source_card_id" in policy["source_cards"]
+    assert "mandatory_required_observation_target_id" in policy["selected_required_observation_ids"]
+    assert "confirm/document" in policy["text_requirement"]
+    assert "Emit selected_required_observation_ids as a trace-only key" in prompt
+    assert "Include every mandatory_source_card_id in source_cards" in prompt
+    assert "retrieved support cards used for safety/SBAR" in prompt
+    assert "Do not add SAFETY-BOUNDARIES-v1 or REFERRAL-SBAR-v1 as candidate pathways" in prompt
+    assert "make the target display_text visible in missing_info_to_collect" in prompt
+    assert "Copy each display_text into missing_info_to_collect" in prompt

tests/test_rules.py

@@ -59,6 +59,48 @@ def test_pregnancy_danger_sign_still_fires_for_confirmed_pregnancy() -> None:
     assert "PREG-001" in _rule_ids(intake)
 
 
+def test_negated_chest_pain_does_not_create_red_flags() -> None:
+    for symptoms in (
+        "fever with chills during postpartum period, no chest pain reported",
+        "cough after dust exposure; no fever, no shortness of breath, no chest pain, speaking normally",
+        "brief lightheadedness after standing; denies fainting, chest pain, weakness, vision change, and shortness of breath",
+        "fatigue after work, denies chest pain, no chest pressure, no trouble breathing",
+    ):
+        intake = {
+            "confirmed": True,
+            "setting": "field clinic",
+            "patient_age": "43",
+            "pregnancy_status": "not_applicable",
+            "chief_concern": "routine check",
+            "symptoms": symptoms,
+            "vitals": "pulse regular",
+            "allergies": "",
+            "medications": "",
+            "available_supplies": "",
+            "responder_note": "",
+        }
+
+        assert "red_flag_chest_pain" not in _rule_ids(intake)
+
+
+def test_positive_chest_pain_still_fires_with_unrelated_negation() -> None:
+    intake = {
+        "confirmed": True,
+        "setting": "field clinic",
+        "patient_age": "54",
+        "pregnancy_status": "not_applicable",
+        "chief_concern": "chest pressure",
+        "symptoms": "no fever, but chest pain with sweating for about twenty minutes",
+        "vitals": "pulse fast",
+        "allergies": "",
+        "medications": "",
+        "available_supplies": "",
+        "responder_note": "",
+    }
+
+    assert "red_flag_chest_pain" in _rule_ids(intake)
+
+
 def test_month_based_pediatric_age_counts_as_pediatric() -> None:
     intake = {
         "confirmed": True,

tests/test_runtime_honesty.py

@@ -182,6 +182,45 @@ def test_trace_and_navigator_ui_show_field_provenance_counts_for_hybrid_output()
     assert "Configured backend" in navigator_html
 
 
+def test_harness_evidence_is_visible_outside_model_authored_text() -> None:
+    app = importlib.import_module("app")
+    evidence = {
+        "confirmed_intake": True,
+        "retrieved_card_ids": ["CHEST-PAIN-ESCALATION-v1", "REFERRAL-SBAR-v1"],
+        "deterministic_rule_ids": ["CHEST-001"],
+        "urgency_floor": "emergency",
+        "validator_status": "passed",
+        "audio_correction_status": "not_applicable",
+        "source_card_ids": ["CHEST-PAIN-ESCALATION-v1"],
+        "final_route": "live_model_generated",
+    }
+    trace = {
+        "events": ["validation complete"],
+        "model_route": {"model_backend": "llama_cpp", "fallback_tier": "configured"},
+        "validator_result": {"passed": True, "failures": []},
+        "navigator_output": {"harness_evidence": evidence},
+        "raw_audio_stored": False,
+    }
+    output = {
+        "protocol_urgency": "emergency",
+        "missing_info_to_collect": ["repeat vitals"],
+        "responder_checklist": [],
+        "do_not_do": [],
+        "source_cards": ["CHEST-PAIN-ESCALATION-v1"],
+        "handoff_note_sbar": {},
+        "harness_evidence": evidence,
+    }
+
+    navigator_html = app._navigator_summary_html(output, trace)
+    trace_html = app._trace_audit_html(trace)
+
+    assert "Harness Evidence" in navigator_html
+    assert "Harness Evidence" in trace_html
+    assert "Retrieved cards: 2" in navigator_html
+    assert "Validation: passed" in navigator_html
+    assert "Harness evidence: visible" in trace_html
+
+
 def test_typed_transcript_audio_draft_is_not_labeled_as_real_omni_audio() -> None:
     app = importlib.import_module("app")
     config = FigmentConfig(

tests/test_validators_strict.py

@@ -60,8 +60,20 @@ def _navigator_output(**overrides: Any) -> dict[str, Any]:
                 "reason_relevant": "Chest pain with shortness of breath was reported.",
             }
         ],
-        "missing_info_to_collect": ["onset and duration", "complete vital signs"],
-        "next_observations_to_collect": ["shortness of breath trend"],
+        "missing_info_to_collect": [
+            "chest pain description",
+            "onset and duration",
+            "shortness of breath report",
+            "sweating or fainting report",
+            "radiation to arm, jaw, back, or shoulder",
+            "available vital signs",
+        ],
+        "next_observations_to_collect": [
+            "chest pain description",
+            "onset and duration",
+            "shortness of breath report",
+            "available vital signs",
+        ],
         "conflicts_or_uncertainties": [],
         "responder_checklist": ["Escalate per cited local protocol."],
         "do_not_do": ["Do not diagnose or prescribe."],
@@ -130,6 +142,34 @@ def test_strict_validator_rejects_known_but_unretrieved_card_citation() -> None:
     assert any("not in allowed/retrieved card IDs" in failure for failure in result.failures)
 
 
+def test_strict_validator_allows_known_fired_rule_card_even_when_retrieval_missed_it() -> None:
+    output = _navigator_output(
+        source_cards=["CHEST-PAIN-ESCALATION-v1"],
+        candidate_protocol_pathways=[
+            {
+                "card_id": "CHEST-PAIN-ESCALATION-v1",
+                "reason_relevant": "Chest pain red flag fired deterministically.",
+            }
+        ],
+    )
+
+    result = validate_navigator_output(
+        output,
+        {
+            "CHEST-PAIN-ESCALATION-v1",
+            "SAFETY-BOUNDARIES-v1",
+            "WOUND-INFECTION-ESCALATION-v1",
+        },
+        urgency_floor="emergency",
+        confirmed_intake=_confirmed_chest_pain_intake(),
+        rule_results=[_chest_rule()],
+        retrieved_card_ids={"SAFETY-BOUNDARIES-v1"},
+        strict_schema=True,
+    )
+
+    assert result.passed
+
+
 def test_strict_validator_rejects_generic_missing_info_and_hallucinated_sbar_facts() -> None:
     output = _navigator_output(
         missing_info_to_collect=["ask anything else that seems relevant"],