'
+
+
def test_consumer_projection_omits_internal_source_material():
response = {**_complete_response(), "answer": {**_complete_response()["answer"], "source_unnormalized": {"raw_html": "secret"}, "worker_stream": [{"token": "secret"}]}}
projection = consumer_projection(response)
@@ -58,6 +63,7 @@ def test_consumer_projection_omits_internal_source_material():
assert "evidence" not in encoded
assert "worker_stream" not in encoded
assert projection["answer"]["procedure"]["title"] == "Starter Replacement Guide"
+ assert projection["answer"]["html"]["ready"] is True
def test_score_response_passes_complete_illustrated_answer():
@@ -65,6 +71,7 @@ def test_score_response_passes_complete_illustrated_answer():
{"name": "camry-starter", "message": "replace starter", "expected_vehicle": {"vehicle_id": "vehicle-1"}, "expected_components": ["starter"], "min_steps": 2, "min_figures": 2},
_complete_response(),
pdf_response=b"%PDF-1.7 test",
+ html_response=_complete_html(),
)
assert result["decision"] == "pass"
assert result["score"] == 100
@@ -76,6 +83,7 @@ def test_score_response_marks_partial_answer_for_review():
response["answer"]["procedure"]["content_status"] = "partial"
response["answer"]["procedure"]["pdf_ready"] = False
response["answer"]["pdf"] = {"ready": False}
+ response["answer"]["html"] = {"ready": False}
result = score_response(
{"name": "partial", "message": "replace starter", "expected_vehicle": {"vehicle_id": "vehicle-1"}, "expected_components": ["starter"], "min_steps": 2, "min_figures": 2},
response,
@@ -99,6 +107,7 @@ def test_score_response_fails_false_complete_replacement_without_both_phases():
},
response,
pdf_response=b"%PDF-1.7 test",
+ html_response=_complete_html(),
)
assert result["decision"] == "fail"
@@ -122,6 +131,7 @@ def test_score_response_requires_case_declared_procedure_depth_terms():
},
_complete_response(),
pdf_response=b"%PDF-1.7 test",
+ html_response=_complete_html(),
)
assert result["decision"] == "needs_review"
assert result["dimensions"]["procedure_coverage"]["passed"] is False
@@ -152,6 +162,7 @@ def test_score_response_flags_provider_summary_artifact_but_preserves_valid_step
},
response,
pdf_response=b"%PDF-1.7 test",
+ html_response=_complete_html(),
)
assert result["decision"] == "needs_review"
@@ -185,6 +196,9 @@ def get(self, _query_id):
def pdf(self, _query_id):
return b"%PDF-1.7 test"
+ def html(self, _query_id):
+ return _complete_html()
+
class TransientPollingClient(FakeChatClient):
def get(self, query_id):
@@ -212,10 +226,29 @@ def test_run_case_selects_vehicle_and_records_revision_hash():
assert client.selected == [("query-12345678", 1)]
assert result["response_sha256"]
assert result["pdf_sha256"]
+ assert result["html_sha256"]
assert result["expected_decision"] == "pass"
assert result["expectation_met"] is True
+def test_html_integrity_rejects_remote_or_invalid_embedded_figures():
+ response = _complete_response()
+ remote = score_response(
+ {"name": "html-remote", "message": "replace starter", "expected_vehicle": {"vehicle_id": "vehicle-1"}, "expected_components": ["starter"], "min_steps": 2, "min_figures": 2},
+ response,
+ pdf_response=b"%PDF-1.7 test",
+ html_response=b'
',
+ )
+ invalid = score_response(
+ {"name": "html-invalid", "message": "replace starter", "expected_vehicle": {"vehicle_id": "vehicle-1"}, "expected_components": ["starter"], "min_steps": 2, "min_figures": 2},
+ response,
+ pdf_response=b"%PDF-1.7 test",
+ html_response=b'
',
+ )
+ assert remote["dimensions"]["html_integrity"]["passed"] is False
+ assert invalid["dimensions"]["html_integrity"]["passed"] is False
+
+
def test_http_client_bounds_and_parses_json_without_logging_auth_material():
seen = []
@@ -243,6 +276,25 @@ def opener(request, timeout):
assert seen[0][3] == 20
+def test_http_client_accepts_standalone_html_with_the_larger_artifact_budget():
+ class Response:
+ def __enter__(self):
+ return self
+
+ def __exit__(self, *_args):
+ return False
+
+ def read(self, _limit):
+ return _complete_html()
+
+ client = ChatHTTPClient(
+ "http://127.0.0.1:8080",
+ opener=lambda _request, timeout: Response(),
+ )
+
+ assert client.html("query-12345678") == _complete_html()
+
+
def test_run_cases_records_aggregate_decision_and_does_not_call_github_for_pass():
with TemporaryDirectory() as directory:
report = run_cases(
diff --git a/workers/ingestion-python/src/autodata_ingestion/autoapitwo_guide.py b/workers/ingestion-python/src/autodata_ingestion/autoapitwo_guide.py
index 81fbdf5..1eca371 100644
--- a/workers/ingestion-python/src/autodata_ingestion/autoapitwo_guide.py
+++ b/workers/ingestion-python/src/autodata_ingestion/autoapitwo_guide.py
@@ -70,11 +70,21 @@ def _vehicle_candidate(raw: Mapping[str, Any], index: int) -> dict[str, Any] | N
return None
body_match = re.search(r"\b(2|4)-Door\b", model_text, re.IGNORECASE)
drive_match = re.search(r"\b(2WD|4WD)\b", model_text, re.IGNORECASE)
- make = re.sub(r"\s+Truck$", "", str(raw.get("make") or "").strip(), flags=re.IGNORECASE)
+ raw_make = str(raw.get("make") or "").strip()
+ make = re.sub(r"\s+Truck$", "", raw_make, flags=re.IGNORECASE)
+ prose_make = re.fullmatch(r"For\s+(?:A|An|The)\s+(.+)", make, re.IGNORECASE)
+ if prose_make and prose_make.group(1).strip():
+ make = prose_make.group(1).strip()
year = _number(raw.get("year"))
if year is None or not make:
return None
candidate_key = f"autoapitwo:{provider_id}"
+ label = description or f"{year} {make} {model}"
+ if prose_make and description:
+ provider_prefix = re.compile(
+ rf"^\s*{year}\s+{re.escape(raw_make)}(?=\s|$)", re.IGNORECASE
+ )
+ label = provider_prefix.sub(f"{year} {make}", description, count=1)
return {
"vehicle_id": f"vehicle:{sha256(candidate_key.encode()).hexdigest()[:24]}",
"candidate_key": candidate_key,
@@ -86,7 +96,7 @@ def _vehicle_candidate(raw: Mapping[str, Any], index: int) -> dict[str, Any] | N
"body_style": body_match.group(1) + "-door" if body_match else None,
"drivetrain": drive_match.group(1).upper() if drive_match else None,
"engine_displacement_l": _engine_litres(raw.get("engine")),
- "label": description or f"{year} {make} {model}",
+ "label": label,
"confidence": 1.0,
}
@@ -232,11 +242,15 @@ def _text(value: Any) -> str:
return re.sub(r"\s+", " ", str(value or "")).strip()
+def _is_malformed_provider_label(label: str) -> bool:
+ return bool(re.match(r"^(?:19|20)\d{2}\s+For\s+(?:A|An|The)\s+", label, re.IGNORECASE))
+
+
def _vehicle_applicability(vehicle: Mapping[str, Any]) -> str:
"""Return the most specific consumer-safe identity for the selected vehicle."""
label = _text(vehicle.get("label"))
- if label:
+ if label and not _is_malformed_provider_label(label):
return label
parts = [
diff --git a/workers/ingestion-python/src/autodata_ingestion/chat_service.py b/workers/ingestion-python/src/autodata_ingestion/chat_service.py
index e8ac5f7..1177083 100644
--- a/workers/ingestion-python/src/autodata_ingestion/chat_service.py
+++ b/workers/ingestion-python/src/autodata_ingestion/chat_service.py
@@ -231,6 +231,8 @@ def claim_due(
_dependencies = ChatDependencies()
_runtime_lock = threading.RLock()
_guide_pdf_cache: dict[str, bytes] = {}
+_guide_html_cache: dict[str, bytes] = {}
+_guide_prepared_cache: dict[str, dict[str, Any]] = {}
_guide_pdf_cache_lock = threading.RLock()
@@ -574,6 +576,12 @@ def select_chat_vehicle(
def get_chat_query(query_id: str, *, principal: Mapping[str, Any] | None = None) -> dict[str, Any]:
+ return _public_query(_get_authorized_query(query_id, principal=principal))
+
+
+def _get_authorized_query(query_id: str, *, principal: Mapping[str, Any] | None) -> dict[str, Any]:
+ """Load one query after authorization for artifact rendering."""
+
query_text = _required_text(query_id, "query_id")
with _runtime_lock:
_require_durable_runtime()
@@ -581,7 +589,7 @@ def get_chat_query(query_id: str, *, principal: Mapping[str, Any] | None = None)
if query is None:
raise KeyError(f"chat query {query_text} was not found")
_authorize_query(query, principal)
- return _public_query(query)
+ return redact_secrets(query)
def iter_chat_events(
@@ -1419,6 +1427,17 @@ def _answer_from_result(
"url": f"/chat/queries/{query_id}/guide.pdf",
"revision_id": str(procedure.get("revision_id") or ""),
}
+ if (
+ isinstance(procedure, Mapping)
+ and procedure.get("content_status") == "complete"
+ and procedure.get("pdf_ready") is True
+ and str(procedure.get("revision_id") or "").strip()
+ ):
+ answer["html"] = {
+ "ready": True,
+ "url": f"/chat/queries/{query_id}/guide.html",
+ "revision_id": str(procedure.get("revision_id") or ""),
+ }
source_watermark = safe.get("source_watermark")
if source_watermark is None and isinstance(safe.get("source"), Mapping):
source_watermark = safe["source"].get("source_watermark") or safe["source"].get("source_version")
@@ -1456,16 +1475,13 @@ def _answer_from_result(
def render_chat_guide_pdf(query_id: str, *, principal: Mapping[str, Any]) -> bytes:
"""Render only the authorized, immutable complete guide revision."""
- query = get_chat_query(query_id, principal=principal)
+ query = _get_authorized_query(query_id, principal=principal)
answer = query.get("answer") if isinstance(query, Mapping) else None
guide = answer.get("procedure") if isinstance(answer, Mapping) else None
if not isinstance(guide, Mapping) or guide.get("pdf_ready") is not True:
raise ValueError("a complete guide PDF is not available")
- from .autoapitwo_connector import AutoAPITwoConnector
from .guide_pdf import render_guide_pdf
- vehicle = guide.get("vehicle") if isinstance(guide.get("vehicle"), Mapping) else answer.get("vehicle", {})
- provider_id = str(vehicle.get("autoapitwo_vehicle_id") or "").strip() if isinstance(vehicle, Mapping) else ""
revision_id = str(guide.get("revision_id") or "").strip()
if not revision_id:
raise ValueError("guide revision is missing")
@@ -1473,17 +1489,90 @@ def render_chat_guide_pdf(query_id: str, *, principal: Mapping[str, Any]) -> byt
cached_pdf = _guide_pdf_cache.get(revision_id)
if cached_pdf is not None:
return cached_pdf
+ prepared = _prepare_guide_for_artifact(guide, answer)
+ rendered = render_guide_pdf(prepared)
+ with _guide_pdf_cache_lock:
+ _guide_pdf_cache[revision_id] = rendered
+ while len(_guide_pdf_cache) > 8:
+ _guide_pdf_cache.pop(next(iter(_guide_pdf_cache)))
+ return rendered
+
+
+def render_chat_guide_html(query_id: str, *, principal: Mapping[str, Any]) -> bytes:
+ """Render only the authorized, immutable complete guide revision as HTML."""
+
+ query = _get_authorized_query(query_id, principal=principal)
+ answer = query.get("answer") if isinstance(query, Mapping) else None
+ guide = answer.get("procedure") if isinstance(answer, Mapping) else None
+ if (
+ not isinstance(guide, Mapping)
+ or guide.get("content_status") != "complete"
+ or guide.get("pdf_ready") is not True
+ ):
+ raise ValueError("a complete guide HTML is not available")
+ revision_id = str(guide.get("revision_id") or "").strip()
+ if not revision_id:
+ raise ValueError("guide revision is missing")
+ with _guide_pdf_cache_lock:
+ cached_html = _guide_html_cache.get(revision_id)
+ if cached_html is not None:
+ return cached_html
+ from .guide_html import render_guide_html
+
+ prepared = _prepare_guide_for_artifact(guide, answer)
+ rendered = render_guide_html(prepared)
+ with _guide_pdf_cache_lock:
+ _guide_html_cache[revision_id] = rendered
+ while len(_guide_html_cache) > 8:
+ _guide_html_cache.pop(next(iter(_guide_html_cache)))
+ return rendered
+
+
+def _prepare_guide_for_artifact(
+ guide: Mapping[str, Any], answer: Mapping[str, Any] | None = None
+) -> dict[str, Any]:
+ """Prepare one immutable guide revision's figures for PDF and HTML."""
+
+ revision_id = str(guide.get("revision_id") or "").strip()
+ if not revision_id:
+ raise ValueError("guide revision is missing")
+ with _guide_pdf_cache_lock:
+ cached = _guide_prepared_cache.get(revision_id)
+ if cached is not None:
+ return deepcopy(cached)
+
+ from .autoapitwo_connector import AutoAPITwoConnector
+
prepared = deepcopy(dict(guide))
+ vehicle = guide.get("vehicle") if isinstance(guide.get("vehicle"), Mapping) else {}
+ if not vehicle and isinstance(answer, Mapping) and isinstance(answer.get("vehicle"), Mapping):
+ vehicle = answer["vehicle"]
+ provider_id = str(vehicle.get("autoapitwo_vehicle_id") or "").strip() if isinstance(vehicle, Mapping) else ""
steps = prepared.get("steps", []) if isinstance(prepared.get("steps"), list) else []
image_refs = [
image
for step in steps
- if isinstance(step, dict)
+ if isinstance(step, Mapping)
for image in (step.get("images", []) if isinstance(step.get("images"), list) else [])
- if isinstance(image, dict) and image.get("url")
+ if isinstance(image, Mapping)
]
- expected_images = len(image_refs)
- unique_urls = list(dict.fromkeys(str(image["url"]) for image in image_refs))
+ top_level_images = prepared.get("images", [])
+ if isinstance(top_level_images, Mapping):
+ top_level_images = [top_level_images]
+ if top_level_images is not None and not isinstance(top_level_images, list):
+ raise ValueError("guide figures could not be prepared")
+ if any(not isinstance(image, Mapping) for image in top_level_images or []):
+ raise ValueError("guide figures could not be prepared")
+ image_refs.extend(
+ image for image in top_level_images or [] if isinstance(image, Mapping)
+ )
+ unique_urls = list(
+ dict.fromkeys(
+ str(image["url"])
+ for image in image_refs
+ if image.get("url") and not image.get("image_bytes")
+ )
+ )
connector = AutoAPITwoConnector(
os.getenv("AUTODATA_AUTOAPITWO_BASE_URL", "https://autoapitwo.vercel.app")
)
@@ -1492,27 +1581,25 @@ def fetch_image(url: str) -> tuple[str, bytes]:
return url, connector.read(url, car_id=provider_id or None, binary=True)
image_bytes: dict[str, bytes] = {}
- with ThreadPoolExecutor(max_workers=min(4, max(1, len(unique_urls)))) as pool:
- for url, value in pool.map(fetch_image, unique_urls):
- image_bytes[url] = value
+ if unique_urls:
+ with ThreadPoolExecutor(max_workers=min(4, len(unique_urls))) as pool:
+ for url, value in pool.map(fetch_image, unique_urls):
+ image_bytes[url] = value
for image in image_refs:
- if str(image["url"]) in image_bytes:
+ if not image.get("image_bytes") and str(image.get("url") or "") in image_bytes:
image["image_bytes"] = image_bytes[str(image["url"])]
- all_images = [
- image
- for step in prepared.get("steps", [])
- if isinstance(prepared.get("steps"), list) and isinstance(step, Mapping)
- for image in (step.get("images", []) if isinstance(step.get("images"), list) else [])
- if isinstance(image, Mapping) and image.get("url")
- ]
- if expected_images and not all(isinstance(image, Mapping) and image.get("image_bytes") for image in all_images):
+ if any(
+ not isinstance(image.get("image_bytes"), (bytes, bytearray, memoryview))
+ or not bytes(image["image_bytes"])
+ for image in image_refs
+ ):
raise ValueError("guide figures could not be prepared")
- rendered = render_guide_pdf(prepared)
+
with _guide_pdf_cache_lock:
- _guide_pdf_cache[revision_id] = rendered
- while len(_guide_pdf_cache) > 8:
- _guide_pdf_cache.pop(next(iter(_guide_pdf_cache)))
- return rendered
+ _guide_prepared_cache[revision_id] = deepcopy(prepared)
+ while len(_guide_prepared_cache) > 8:
+ _guide_prepared_cache.pop(next(iter(_guide_prepared_cache)))
+ return prepared
def _apply_answer(query: dict[str, Any], answer: Mapping[str, Any]) -> None:
@@ -2066,5 +2153,7 @@ def _ack_chat_claim(claim: Any) -> None:
"process_chat_jobs",
"process_chat_price_jobs",
"publish_chat_progress",
+ "render_chat_guide_html",
+ "render_chat_guide_pdf",
"select_chat_vehicle",
]
diff --git a/workers/ingestion-python/src/autodata_ingestion/guide_html.py b/workers/ingestion-python/src/autodata_ingestion/guide_html.py
new file mode 100644
index 0000000..f937b27
--- /dev/null
+++ b/workers/ingestion-python/src/autodata_ingestion/guide_html.py
@@ -0,0 +1,337 @@
+"""Deterministic standalone HTML rendering for complete repair guides."""
+
+from __future__ import annotations
+
+from base64 import b64encode
+from html import escape
+import re
+from typing import Any, Mapping
+
+
+_GENERIC_FIGURE_CAPTIONS = frozenset(
+ {
+ "diagram",
+ "figure",
+ "image",
+ "picture",
+ "procedure figure",
+ "source diagram",
+ }
+)
+
+_INLINE_CSS = """
+:root { color-scheme: light; font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; color: #27352f; background: #f5f8f6; }
+body { max-width: 48rem; margin: 0 auto; padding: 2rem 1.25rem 3rem; background: #fff; line-height: 1.55; }
+h1, h2, h3 { color: #17231f; line-height: 1.2; }
+h1 { margin: 0 0 .35rem; font-size: 2rem; }
+h2 { margin-top: 2rem; border-bottom: 1px solid #d8e0db; padding-bottom: .35rem; }
+h3 { margin: 0 0 .35rem; font-size: 1.05rem; }
+.subtitle { margin: 0 0 1.25rem; color: #53625c; font-size: 1.05rem; }
+.metadata { display: grid; grid-template-columns: max-content 1fr; gap: .3rem .8rem; margin: 1rem 0 1.5rem; padding: .9rem 1rem; background: #eef4f0; border-radius: .5rem; font-size: .9rem; }
+.metadata dt { font-weight: 700; color: #53625c; }
+.metadata dd { margin: 0; overflow-wrap: anywhere; }
+.warning { margin: .75rem 0; padding: .75rem 1rem; border-left: .3rem solid #e7b24a; background: #fff5df; }
+.steps { padding-left: 1.75rem; }
+.step { padding: .2rem 0 1.2rem .35rem; }
+.instruction { margin: .35rem 0; }
+figure { margin: 1rem 0; padding: .75rem; background: #f5f8f6; border: 1px solid #d8e0db; border-radius: .4rem; }
+img { display: block; max-width: 100%; height: auto; margin: 0 auto; }
+figcaption { margin-top: .55rem; color: #53625c; font-size: .88rem; text-align: center; }
+.evidence { margin: .55rem 0 0; color: #53625c; font-size: .85rem; }
+.evidence ul { margin: .2rem 0 0; }
+footer { margin-top: 2rem; padding-top: .8rem; border-top: 1px solid #d8e0db; color: #53625c; font-size: .82rem; }
+""".strip()
+
+_EXTENSION_MEDIA_TYPES = {
+ ".bmp": "image/bmp",
+ ".gif": "image/gif",
+ ".jpeg": "image/jpeg",
+ ".jpg": "image/jpeg",
+ ".png": "image/png",
+ ".svg": "image/svg+xml",
+ ".tif": "image/tiff",
+ ".tiff": "image/tiff",
+ ".webp": "image/webp",
+}
+
+
+def _text(value: Any) -> str:
+ if isinstance(value, Mapping):
+ value = value.get("message", value.get("text", value.get("description", "")))
+ return str(value or "").strip()
+
+
+def _escaped(value: Any) -> str:
+ return escape(_text(value), quote=False)
+
+
+def _attribute(value: Any) -> str:
+ return escape(_text(value), quote=True)
+
+
+def _caption(image: Mapping[str, Any]) -> str:
+ for key in ("alt", "description", "label", "title"):
+ value = _text(image.get(key))
+ if value and value.casefold() not in _GENERIC_FIGURE_CAPTIONS:
+ return value
+ return ""
+
+
+def _media_type(image: Mapping[str, Any]) -> str:
+ for key in ("media_type", "mime_type", "content_type"):
+ value = _text(image.get(key)).split(";", 1)[0].casefold()
+ if value.startswith("image/") and re.fullmatch(r"image/[a-z0-9.+-]+", value):
+ return value
+
+ url = _text(image.get("url"))
+ extension = re.search(r"(\.[a-z0-9]+)(?:[?#]|$)", url.casefold())
+ if extension and extension.group(1) in _EXTENSION_MEDIA_TYPES:
+ return _EXTENSION_MEDIA_TYPES[extension.group(1)]
+
+ payload = image.get("image_bytes")
+ if isinstance(payload, (bytes, bytearray, memoryview)):
+ raw = bytes(payload)
+ if raw.startswith(b"\x89PNG"):
+ return "image/png"
+ if raw.startswith(b"\xff\xd8\xff"):
+ return "image/jpeg"
+ if raw.startswith((b"GIF87a", b"GIF89a")):
+ return "image/gif"
+ if raw.startswith(b"RIFF") and raw[8:12] == b"WEBP":
+ return "image/webp"
+ if raw.lstrip().startswith(b"{_escaped(guide.get('title') or 'AutoData Repair Guide')}
", + f'{_escaped(guide.get("applicability") or "Vehicle-specific procedure")}
', + ' "]) + + preparation = guide.get("preparation", []) + if isinstance(preparation, str): + preparation = [preparation] + if isinstance(preparation, list) and preparation: + lines.extend(["Before you begin
", "- "])
+ for item in preparation:
+ lines.append(f"
- {_escaped(item)} ") + lines.append("
Safety notes
"]) + for item in warnings: + lines.append(f'Important: {_escaped(item)}
') + + lines.extend(["Procedure
", '- '])
+ guide_evidence = sorted(
+ set(_evidence_ids(guide.get("evidence_ids")))
+ | set(_evidence_ids(guide.get("evidence")))
+ )
+ rendered_images: set[tuple[str, bytes | str]] = set()
+ for index, item in enumerate(steps, start=1):
+ if not isinstance(item, Mapping):
+ continue
+ sequence_value = item.get("sequence", index)
+ try:
+ sequence = int(sequence_value)
+ except (TypeError, ValueError):
+ sequence = index
+ action = _step_action(item.get("action"), sequence)
+ lines.extend(["
- ", f"
Step {sequence}: {_escaped(action)}
"]) + instructions = item.get("instructions", []) + if isinstance(instructions, str): + instructions = [instructions] + if isinstance(instructions, list): + for instruction in instructions: + lines.append(f'{_escaped(instruction)}
') + + images = item.get("images", []) + if not isinstance(images, list): + images = [] + for image in images: + if not isinstance(image, Mapping): + raise ValueError("all guide figures must be prepared before HTML rendering") + _render_figure(lines, image) + rendered_images.add(_image_key(image)) + + image_evidence = [ + image_evidence_id + for image in images + if isinstance(image, Mapping) + for image_evidence_id in _evidence_ids(image.get("evidence_ids") or image.get("evidence_id")) + ] + evidence = sorted( + set(guide_evidence) + | set(_evidence_ids(item.get("evidence_ids"))) + | set(_evidence_ids(item.get("evidence"))) + | set(image_evidence) + ) + if evidence: + lines.extend([ + 'Evidence references:', + "", + ]) + lines.append("- ",
+ *[f"
- {_escaped(value)} " for value in evidence], + "
")
+ lines.extend(["
Figures
", ''])
+ for image in extra_images:
+ _render_figure(lines, image, indent=" ")
+ lines.append("
")
+
+ if guide_evidence:
+ lines.extend([
+ " Evidence references
", + '- ',
+ *[f"
- {_escaped(value)} " for value in guide_evidence], + "