@dzhechkov/p-replicator 1.12.0 → 1.13.2

package/templates/.claude/skills/goap-research-ed25519/scripts/quote_provenance.py

@@ -0,0 +1,342 @@
+#!/usr/bin/env python3
+"""Deterministic quote provenance over bounded, witness-captured excerpts.
+
+The normalization corridor is CLOSED and shared by capture and verification:
+Unicode NFC; HTML entity decoding for HTML bodies; whitespace-run collapse;
+and only these typography folds: «»„“” -> ``"`` and —– -> ``-``. Case and
+words are never changed, and word-overlap is never a verbatim check.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import html
+import json
+import os
+import re
+import tempfile
+import unicodedata
+from dataclasses import asdict, dataclass
+from email.message import Message
+from typing import Any, Dict, Mapping, Optional, Tuple
+
+ACQUISITION_METHODS = ("raw-fetch", "tool-summary", "search-listing", "manual")
+METHOD_UNKNOWN = "method-unknown"
+VERBATIM_VERDICTS = (
+    "verbatim-confirmed",
+    "not-in-excerpt",
+    "no-excerpt",
+    "method-ineligible",
+    "hash-mismatch",
+    METHOD_UNKNOWN,
+)
+
+EXCERPT_RADIUS_CHARS = 500
+EXCERPT_MAX_CHARS = 2000
+_TYPOGRAPHY_FOLD = str.maketrans({
+    "«": '"', "»": '"', "„": '"', "“": '"', "”": '"',
+    "—": "-", "–": "-",
+})
+_HTML_ENTITY_RE = re.compile(r"&(?:#\d+|#x[0-9a-fA-F]+|[A-Za-z][A-Za-z0-9]+);")
+
+
+class ExcerptCaptureRefused(ValueError):
+    """A named author-time refusal before an excerpt can be persisted."""
+
+
+class ExcerptStoreError(ValueError):
+    """The excerpt store exists but cannot be interpreted safely."""
+
+
+@dataclass(frozen=True)
+class QuoteRecord:
+    quote: str
+    acquisition: str
+    source_url: str
+    sha256_body: str
+    locator: Optional[str] = None
+    excerpt_id: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.quote, str) or not self.quote.strip():
+            raise ValueError("quote must be a non-blank string")
+        if self.acquisition not in ACQUISITION_METHODS:
+            raise ValueError(
+                f"acquisition {self.acquisition!r} is outside the closed set {ACQUISITION_METHODS}"
+            )
+        if not isinstance(self.source_url, str) or not self.source_url.strip():
+            raise ValueError("source_url must be a non-blank string")
+        if not isinstance(self.sha256_body, str) or not re.fullmatch(r"[0-9a-f]{64}", self.sha256_body):
+            raise ValueError("sha256_body must be 64 lowercase hexadecimal characters")
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+def read_acquisition(value_or_none: Any) -> str:
+    """Read-side compatibility: absent or unknown stays unknown and grants nothing."""
+    return value_or_none if value_or_none in ACQUISITION_METHODS else METHOD_UNKNOWN
+
+
+def _content_type_parts(content_type: Any) -> Tuple[Optional[str], Optional[str]]:
+    if not isinstance(content_type, str) or not content_type.strip():
+        return None, None
+    message = Message()
+    message["content-type"] = content_type
+    mime = message.get_content_type().lower()
+    charset = message.get_content_charset() or "utf-8"
+    return mime, charset
+
+
+def _is_decodable_mime(mime: Optional[str]) -> bool:
+    if mime is None:
+        return False
+    return (
+        mime.startswith("text/")
+        or mime in {
+            "application/json", "application/ld+json", "application/xml",
+            "application/xhtml+xml", "application/javascript",
+        }
+        or mime.endswith("+json")
+        or mime.endswith("+xml")
+    )
+
+
+def _decode_body(body: Any, content_type: Any) -> Tuple[str, str, str]:
+    mime, charset = _content_type_parts(content_type)
+    if not _is_decodable_mime(mime):
+        raise ExcerptCaptureRefused(
+            f"non-text body with content_type {content_type!r} cannot produce verbatim evidence"
+        )
+    if not isinstance(body, (bytes, bytearray, memoryview)):
+        raise ExcerptCaptureRefused("source body must be bytes captured by the fetch path")
+    try:
+        return bytes(body).decode(charset or "utf-8", errors="strict"), mime or "", charset or "utf-8"
+    except (LookupError, UnicodeDecodeError) as exc:
+        raise ExcerptCaptureRefused(
+            f"undecodable source body under declared charset {charset!r}: {exc}"
+        ) from None
+
+
+def _html_unescape_with_offsets(text: str) -> Tuple[str, list]:
+    output = []
+    offsets = []
+    cursor = 0
+    for match in _HTML_ENTITY_RE.finditer(text):
+        for index in range(cursor, match.start()):
+            output.append(text[index])
+            offsets.append(index)
+        decoded = html.unescape(match.group(0))
+        for char in decoded:
+            output.append(char)
+            offsets.append(match.start())
+        cursor = match.end()
+    for index in range(cursor, len(text)):
+        output.append(text[index])
+        offsets.append(index)
+    return "".join(output), offsets
+
+
+def _normalize_with_offsets(text: str, *, is_html: bool) -> Tuple[str, list]:
+    if is_html:
+        current, offsets = _html_unescape_with_offsets(text)
+    else:
+        current, offsets = text, list(range(len(text)))
+
+    nfc_chars = []
+    nfc_offsets = []
+    index = 0
+    while index < len(current):
+        end = index + 1
+        while end < len(current) and unicodedata.combining(current[end]):
+            end += 1
+        normalized = unicodedata.normalize("NFC", current[index:end])
+        for char in normalized:
+            nfc_chars.append(char.translate(_TYPOGRAPHY_FOLD))
+            nfc_offsets.append(offsets[index])
+        index = end
+
+    collapsed = []
+    collapsed_offsets = []
+    in_whitespace = False
+    for char, original_offset in zip(nfc_chars, nfc_offsets):
+        if char.isspace():
+            if not in_whitespace:
+                collapsed.append(" ")
+                collapsed_offsets.append(original_offset)
+            in_whitespace = True
+        else:
+            collapsed.append(char)
+            collapsed_offsets.append(original_offset)
+            in_whitespace = False
+    return "".join(collapsed), collapsed_offsets
+
+
+def normalize_text(text: str, content_type: Optional[str] = "text/plain; charset=utf-8") -> str:
+    """Apply the closed normalization corridor; never lowercase or paraphrase."""
+    if not isinstance(text, str):
+        raise TypeError(f"text must be str, got {type(text).__name__}")
+    mime, _ = _content_type_parts(content_type)
+    normalized, _ = _normalize_with_offsets(text, is_html=bool(mime and "html" in mime))
+    return normalized
+
+
+def _record_value(record: Any, name: str, default: Any = None) -> Any:
+    if isinstance(record, Mapping):
+        return record.get(name, default)
+    return getattr(record, name, default)
+
+
+def capture_excerpt(body: bytes, quote: str, record: Any) -> Dict[str, Any]:
+    """Cut a bounded excerpt only after authentic FetchRecord/body hash agreement."""
+    if not getattr(record, "is_authentic", None) or not record.is_authentic():
+        raise ExcerptCaptureRefused(
+            "excerpt capture requires an authentic FetchRecord from evidence_fetch.fetch_source()"
+        )
+    if not isinstance(quote, str) or not quote.strip():
+        raise ExcerptCaptureRefused("quote must be a non-blank string")
+    raw = bytes(body) if isinstance(body, (bytes, bytearray, memoryview)) else body
+    if not isinstance(raw, bytes):
+        raise ExcerptCaptureRefused("source body must be bytes captured by the fetch path")
+    body_hash = hashlib.sha256(raw).hexdigest()
+    if body_hash != getattr(record, "sha256_body", None):
+        raise ExcerptCaptureRefused(
+            "hash-mismatch: source bytes do not match the FetchRecord.sha256_body witness"
+        )
+
+    text, mime, encoding = _decode_body(raw, getattr(record, "content_type", None))
+    normalized_body, offsets = _normalize_with_offsets(text, is_html="html" in mime)
+    normalized_quote = normalize_text(quote, getattr(record, "content_type", None))
+    if len(quote) > EXCERPT_MAX_CHARS or len(normalized_quote) > EXCERPT_MAX_CHARS:
+        raise ExcerptCaptureRefused(
+            f"excerpt too narrow: quote exceeds EXCERPT_MAX_CHARS={EXCERPT_MAX_CHARS}"
+        )
+    found = normalized_body.find(normalized_quote)
+    if found < 0:
+        raise ExcerptCaptureRefused(f"quote absent from captured source bytes: {quote!r}")
+
+    raw_start = offsets[found]
+    raw_end = offsets[found + len(normalized_quote) - 1] + 1
+    start = max(0, raw_start - EXCERPT_RADIUS_CHARS)
+    end = min(len(text), raw_end + EXCERPT_RADIUS_CHARS)
+    if end - start > EXCERPT_MAX_CHARS:
+        surplus = (end - start) - EXCERPT_MAX_CHARS
+        trim_left = min(surplus // 2, raw_start - start)
+        start += trim_left
+        surplus -= trim_left
+        end -= min(surplus, end - raw_end)
+    if end - start > EXCERPT_MAX_CHARS or start > raw_start or end < raw_end:
+        raise ExcerptCaptureRefused(
+            f"excerpt too narrow: quote cannot fit inside EXCERPT_MAX_CHARS={EXCERPT_MAX_CHARS}"
+        )
+
+    excerpt = text[start:end]
+    excerpt_hash = hashlib.sha256(excerpt.encode("utf-8")).hexdigest()
+    quote_hash = hashlib.sha256(quote.encode("utf-8")).hexdigest()
+    excerpt_id = f"{body_hash[:16]}-{quote_hash[:8]}.json"
+    try:
+        excerpt_offset = len(text[:start].encode(encoding, errors="strict"))
+    except (LookupError, UnicodeEncodeError) as exc:
+        raise ExcerptCaptureRefused(
+            f"cannot reproduce excerpt byte offset under declared charset {encoding!r}: {exc}"
+        ) from None
+    return {
+        "excerpt_id": excerpt_id,
+        "sha256_body": body_hash,
+        "fetched_at": getattr(record, "fetched_at", None),
+        "source_url": getattr(record, "final_url", None),
+        "excerpt": excerpt,
+        "excerpt_offset": excerpt_offset,
+        "radius_chars": EXCERPT_RADIUS_CHARS,
+        "encoding": encoding,
+        "content_type": getattr(record, "content_type", None),
+        "sha256_excerpt": excerpt_hash,
+    }
+
+
+def _atomic_write(path: str, text: str) -> None:
+    fd, temporary = tempfile.mkstemp(prefix=".quote-provenance-", dir=os.path.dirname(path), text=True)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle:
+            handle.write(text)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temporary, path)
+    except Exception:
+        try:
+            os.unlink(temporary)
+        except OSError:
+            pass
+        raise
+
+
+def write_excerpt(directory: str, excerpt_rec: Mapping[str, Any]) -> str:
+    """Atomically write one excerpt and make its fresh store self-gitignoring."""
+    if not isinstance(excerpt_rec, Mapping):
+        raise ExcerptStoreError("excerpt record must be a mapping")
+    excerpt_id = excerpt_rec.get("excerpt_id")
+    if not isinstance(excerpt_id, str) or not excerpt_id or os.path.basename(excerpt_id) != excerpt_id:
+        raise ExcerptStoreError("excerpt_id must be a non-empty basename")
+    os.makedirs(directory, exist_ok=True)
+    ignore_path = os.path.join(directory, ".gitignore")
+    if not os.path.exists(ignore_path):
+        _atomic_write(ignore_path, "*\n")
+    target = os.path.join(directory, excerpt_id)
+    try:
+        payload = json.dumps(dict(excerpt_rec), ensure_ascii=False, sort_keys=True, indent=2) + "\n"
+        _atomic_write(target, payload)
+    except (OSError, TypeError, ValueError) as exc:
+        raise ExcerptStoreError(f"cannot write excerpt {excerpt_id!r}: {exc}") from None
+    return target
+
+
+def load_excerpt(directory: str, excerpt_id: Any) -> Optional[Dict[str, Any]]:
+    """Load one store leaf. Missing material is distinct from an unreadable store."""
+    if not isinstance(excerpt_id, str) or not excerpt_id:
+        return None
+    if os.path.basename(excerpt_id) != excerpt_id:
+        raise ExcerptStoreError(f"unsafe excerpt_id {excerpt_id!r}")
+    path = os.path.join(directory, excerpt_id)
+    try:
+        with open(path, "r", encoding="utf-8") as handle:
+            data = json.load(handle)
+    except FileNotFoundError:
+        return None
+    except (OSError, UnicodeError, json.JSONDecodeError) as exc:
+        raise ExcerptStoreError(f"cannot read excerpt {excerpt_id!r}: {exc}") from None
+    if not isinstance(data, dict):
+        raise ExcerptStoreError(f"excerpt {excerpt_id!r} is not a JSON object")
+    return data
+
+
+def verify_verbatim(span: str, excerpt_rec: Any, fact: Any) -> str:
+    """Return one closed verdict; only an exact normalized leaf match can confirm."""
+    acquisition = read_acquisition(_record_value(fact, "acquisition"))
+    if acquisition == METHOD_UNKNOWN:
+        return METHOD_UNKNOWN
+    if acquisition == "tool-summary":
+        return "method-ineligible"
+    if isinstance(excerpt_rec, (list, tuple)):
+        return "not-in-excerpt"  # a JOIN of leaves is never a source leaf
+    if not isinstance(excerpt_rec, Mapping) or not isinstance(excerpt_rec.get("excerpt"), str):
+        return "no-excerpt"
+    mime, _ = _content_type_parts(excerpt_rec.get("content_type"))
+    if not _is_decodable_mime(mime):
+        return "no-excerpt"
+    excerpt = excerpt_rec["excerpt"]
+    expected_excerpt_hash = excerpt_rec.get("sha256_excerpt")
+    actual_excerpt_hash = hashlib.sha256(excerpt.encode("utf-8")).hexdigest()
+    if not isinstance(expected_excerpt_hash, str) or expected_excerpt_hash != actual_excerpt_hash:
+        return "hash-mismatch"
+    fact_body_hash = _record_value(fact, "sha256_body")
+    if not isinstance(fact_body_hash, str) or fact_body_hash != excerpt_rec.get("sha256_body"):
+        return "hash-mismatch"
+    fact_url = _record_value(fact, "source_url")
+    if fact_url and excerpt_rec.get("source_url") and fact_url != excerpt_rec.get("source_url"):
+        return "hash-mismatch"
+    try:
+        normalized_span = normalize_text(span, excerpt_rec.get("content_type"))
+        normalized_excerpt = normalize_text(excerpt, excerpt_rec.get("content_type"))
+    except (TypeError, ValueError):
+        return "no-excerpt"
+    return "verbatim-confirmed" if normalized_span in normalized_excerpt else "not-in-excerpt"

package/templates/.claude/skills/goap-research-ed25519/scripts/test_ed25519_verifier.py

@@ -14,6 +14,7 @@ test_*.py`, so a module that stops being collected fails BY NAME.
 """
 
 import copy
+import hashlib
 import sys
 
 # Import NOTHING local before this line: a stray __pycache__ inside this vendored
@@ -23,6 +24,8 @@ sys.dont_write_bytecode = True
 import unittest
 
 import ed25519_verifier as ev
+import evidence_fetch as ef
+import quote_provenance as qp
 
 
 def _pop():
@@ -162,6 +165,63 @@ class Ed25519VerifierSecurityTests(unittest.TestCase):
         self.assertFalse(reordered_ok)
         self.assertIn("Invalid", reordered_error)
 
+    def test_schema_v4_signs_quote_provenance_and_tamper_fails(self):
+        signer = ev.Ed25519Verifier(auto_generate_keypair=True)
+        body = b"The source explicitly recommends gradual refeeding."
+        record = ef.FetchRecord(
+            url="https://example.test/source",
+            final_url="https://example.test/source",
+            status=200,
+            sha256_body=hashlib.sha256(body).hexdigest(),
+            bytes_len=len(body),
+            fetched_at="2026-09-02T00:00:00Z",
+            content_type="text/plain; charset=utf-8",
+            witness=ef._FETCH_WITNESS,
+        )
+        quote = qp.QuoteRecord(
+            quote="The source explicitly recommends gradual refeeding",
+            acquisition="raw-fetch",
+            source_url=record.final_url,
+            sha256_body=record.sha256_body,
+            locator="paragraph 1",
+            excerpt_id="quote.json",
+        )
+        fact = signer.create_fetched_fact(
+            claim=quote.quote,
+            fetch_record=record,
+            issuer="researcher",
+            study_population=_pop(),
+            quote=quote,
+        )
+
+        result = signer.verify_fact(fact)
+        self.assertTrue(result.verified, result.error)
+        self.assertEqual(ev.fact_schema_version(fact), ev.QUOTE_ATTESTED_MIN_SCHEMA)
+        self.assertIn("quote", result.signed_fields)
+        self.assertIn("acquisition", result.signed_fields)
+        self.assertIn("sha256_body", result.signed_fields)
+
+        tampered = copy.deepcopy(fact)
+        tampered.quote = "The source recommends immediate supplementation"
+        self.assertFalse(signer.verify_fact(tampered).verified)
+
+    def test_non_fetch_factory_cannot_claim_raw_fetch_acquisition(self):
+        signer = ev.Ed25519Verifier(auto_generate_keypair=True)
+        quote = qp.QuoteRecord(
+            quote="A raw quote",
+            acquisition="raw-fetch",
+            source_url="https://example.test/source",
+            sha256_body="a" * 64,
+        )
+        with self.assertRaisesRegex(ValueError, "requires create_fetched_fact"):
+            signer.create_listing_fact(
+                claim=quote.quote,
+                source_url=quote.source_url,
+                reason="listing only",
+                study_population=_pop(),
+                quote=quote,
+            )
+
 
 if __name__ == "__main__":
     unittest.main()

package/templates/.claude/skills/goap-research-ed25519/scripts/test_evidence_provenance.py

@@ -30,6 +30,7 @@ import ed25519_verifier as ev
 import evidence_fetch as ef
 import source_tiers as st
 import check_report_evidence as gate
+import quote_provenance as qp
 
 
 def _verifier():
@@ -307,15 +308,63 @@ class FetchTests(unittest.TestCase):
             def log_message(self, *args):  # silence
                 pass
 
-        cls.server = HTTPServer(("127.0.0.1", 0), Handler)
-        cls.port = cls.server.server_address[1]
-        cls.thread = threading.Thread(target=cls.server.serve_forever, daemon=True)
-        cls.thread.start()
+        cls._original_build_opener = None
+        try:
+            cls.server = HTTPServer(("127.0.0.1", 0), Handler)
+        except PermissionError:
+            # Managed coding sandboxes can forbid even loopback sockets. Preserve
+            # every existing fetch assertion with a response-level fallback; on a
+            # normal host the real HTTPServer path above remains the path exercised.
+            cls.server = None
+            cls.port = 80
+            cls._original_build_opener = ef.urlrequest.build_opener
+
+            class Response:
+                def __init__(self, body, url, status=200, content_type="text/plain"):
+                    self.body = body
+                    self.url = url
+                    self.status = status
+                    self.headers = {"Content-Type": content_type}
+
+                def __enter__(self):
+                    return self
+
+                def __exit__(self, *unused):
+                    return False
+
+                def read(self, limit):
+                    return self.body[:limit]
+
+                def getcode(self):
+                    return self.status
+
+                def geturl(self):
+                    return self.url
+
+            class Opener:
+                def open(self, request, timeout=None):
+                    url = request.full_url
+                    if url.endswith("/ok"):
+                        return Response(b"hello evidence", url)
+                    if url.endswith("/redirect"):
+                        return Response(b"hello evidence", url[:-len("redirect")] + "ok")
+                    if url.endswith("/big"):
+                        return Response(b"x" * 4096, url)
+                    raise ef.urlerror.HTTPError(url, 404, "Not Found", {}, None)
+
+            ef.urlrequest.build_opener = lambda *unused: Opener()
+        else:
+            cls.port = cls.server.server_address[1]
+            cls.thread = threading.Thread(target=cls.server.serve_forever, daemon=True)
+            cls.thread.start()
 
     @classmethod
     def tearDownClass(cls):
-        cls.server.shutdown()
-        cls.server.server_close()
+        if cls.server is not None:
+            cls.server.shutdown()
+            cls.server.server_close()
+        if cls._original_build_opener is not None:
+            ef.urlrequest.build_opener = cls._original_build_opener
 
     def _url(self, path):
         return f"http://127.0.0.1:{self.port}{path}"
@@ -328,6 +377,15 @@ class FetchTests(unittest.TestCase):
         self.assertEqual(record.sha256_body, hashlib.sha256(b"hello evidence").hexdigest())
         self.assertTrue(record.fetched_at.endswith("Z"))
 
+    def test_body_returning_seam_preserves_the_compatibility_record(self):
+        from unittest import mock
+        fixed_time = "2026-09-02T00:00:00Z"
+        with mock.patch.object(ef, "_now_iso", return_value=fixed_time):
+            seam_record, body = ef.fetch_source_returning_body(self._url("/ok"), _allow_private=True)
+            wrapper_record = ef.fetch_source(self._url("/ok"), _allow_private=True)
+        self.assertEqual(body, b"hello evidence")
+        self.assertEqual(seam_record.to_dict(), wrapper_record.to_dict())
+
     def test_redirect_is_followed_and_final_url_recorded(self):
         record = ef.fetch_source(self._url("/redirect"), _allow_private=True)
         self.assertIsInstance(record, ef.FetchRecord)
@@ -447,6 +505,81 @@ class ReportGateTests(unittest.TestCase):
             self.assertEqual(gate.main(["--report", report_path, "--facts", os.path.join(tmp, "nope.json")]), 2)
 
 
+class QuoteProvenanceGateTests(unittest.TestCase):
+    """ADR quote-provenance Confirmation: source bytes, never author status, decide."""
+
+    quote = "The source explicitly recommends gradual refeeding"
+    source_url = "https://example.test/source"
+
+    def _fixture(self, directory, excerpt_text, **fact_overrides):
+        body_hash = ev.hashlib.sha256(excerpt_text.encode("utf-8")).hexdigest()
+        excerpt_id = "quote.json"
+        excerpt = {
+            "sha256_body": body_hash,
+            "fetched_at": "2026-09-02T00:00:00Z",
+            "source_url": self.source_url,
+            "excerpt": excerpt_text,
+            "excerpt_offset": 0,
+            "radius_chars": 500,
+            "encoding": "utf-8",
+            "content_type": "text/plain; charset=utf-8",
+            "sha256_excerpt": ev.hashlib.sha256(excerpt_text.encode("utf-8")).hexdigest(),
+        }
+        with open(os.path.join(directory, excerpt_id), "w", encoding="utf-8") as handle:
+            json.dump(excerpt, handle)
+        fact = {
+            "claim": self.quote,
+            "source_url": self.source_url,
+            "evidence_class": "FETCH_VERIFIED",
+            "schema_version": 4,
+            "quote": self.quote,
+            "acquisition": "raw-fetch",
+            "sha256_body": body_hash,
+            "locator": "paragraph 1",
+            "excerpt_id": excerpt_id,
+        }
+        fact.update(fact_overrides)
+        return fact
+
+    def test_report_quote_absent_from_source_body_is_named_violation(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmp:
+            fact = self._fixture(tmp, "The source discusses measured recovery outcomes.")
+            findings, _ = gate.evaluate_quotes(f'The report says "{self.quote}".', [fact], tmp)
+        self.assertEqual([finding.kind for finding in findings], ["QUOTE_NOT_IN_SOURCE"])
+        self.assertIn(self.quote, findings[0].detail)
+
+    def test_report_quote_present_in_source_body_passes(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmp:
+            fact = self._fixture(tmp, f"Methods. {self.quote}. Results.")
+            findings, counts = gate.evaluate_quotes(f'The report says "{self.quote}".', [fact], tmp)
+        self.assertEqual(findings, [])
+        self.assertEqual(counts["quote-verbatim-confirmed"], 1)
+
+    def test_author_supplied_verbatim_status_is_ignored_and_downgraded(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmp:
+            fact = self._fixture(
+                tmp,
+                "The source discusses measured recovery outcomes.",
+                verbatim_status="verbatim",
+            )
+            findings, _ = gate.evaluate_quotes(f'The report says "{self.quote}".', [fact], tmp)
+        self.assertEqual([finding.kind for finding in findings], ["QUOTE_NOT_IN_SOURCE"])
+        self.assertIn("not-in-excerpt", findings[0].detail)
+
+    def test_unreadable_excerpt_store_never_reads_as_clean(self):
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmp:
+            fact = self._fixture(tmp, self.quote)
+            with open(os.path.join(tmp, fact["excerpt_id"]), "w", encoding="utf-8") as handle:
+                handle.write("not json")
+            findings, counts = gate.evaluate_quotes(f'The report says "{self.quote}".', [fact], tmp)
+        self.assertEqual([finding.kind for finding in findings], ["QUOTES_UNCHECKED"])
+        self.assertEqual(counts["quote-unchecked"], 1)
+
+
 
 
 class HardeningTests(unittest.TestCase):