@dzhechkov/p-replicator 1.12.0 → 1.13.2

package/templates/.claude/skills/goap-research-ed25519/SKILL.md

@@ -42,6 +42,17 @@ record of something recited from memory. That combination is legal, expressible,
 | `ASSERTED` | Stated from model memory, source never opened | Nothing about the source | `0.0` |
 | *(absent)* | Fact predates this axis | Evidence is **unknown** — neither asserted nor verified | no ceiling of its own |
 
+For quoted text, the acquisition method is a separate closed vocabulary. The author-facing names
+map exactly to the stored values; only the verifier can emit the verdict after comparing captured bytes.
+
+| Stored method | Author-facing name | Verbatim ceiling |
+|---|---|---|
+| `raw-fetch` | `сырая-загрузка` | eligible only after a matching captured excerpt |
+| `tool-summary` | `пересказ-инструментом` | never verbatim, even when the words happen to match |
+| `search-listing` | `из-поисковой-выдачи` | eligible only after reconciliation against a captured excerpt |
+| `manual` | `вручную` | eligible only after reconciliation against a captured excerpt |
+| *(absent/other)* | `method-unknown` | never verbatim |
+
 **`FETCH_VERIFIED` cannot be self-declared.** It is minted only by `create_fetched_fact()`, which
 requires a `FetchRecord` — the byte hash, HTTP status and date of a request that actually happened.
 The manual constructors (`create_listing_fact`, `create_asserted_fact`) have no way to produce it.
@@ -54,7 +65,7 @@ Provenance, not truth.
 ### The report gate
 
 ```bash
-python3 scripts/check_report_evidence.py --report report.md --facts facts.json [--profile patient.json]
+python3 scripts/check_report_evidence.py --report report.md --facts facts.json [--profile patient.json] [--excerpts evidence_excerpts]
 ```
 
 `ASSERTED` claims must not appear in a report at all. `LISTING_ONLY` claims may appear only with a
@@ -197,12 +208,10 @@ mkdir ~/health-research && cd ~/health-research     # medical work lives here
 Do not run medical investigations inside a shared code repository. If you already have,
 the prompt log is `.dz/recall-usage.jsonl` and the lessons are in `.health-brain/`.
 
-Choosing the shared store anyway is not blocked — it is ADVISED against. `dz teach
---domain health-research` into a shared store prints what follows from the choice and
-the command that does it the other way; `dz recall --all --json --include-domain
-health-research` hands the data over and says how much of it is medical. Both end with
-"Nothing was blocked — this is your call." The data is yours; our job is that the choice
-is knowing rather than accidental.
+Choosing the shared store anyway is ADVISED against, never blocked: both `dz teach --domain
+health-research` and `dz recall --all --json --include-domain health-research` print what follows
+from the choice and end with "Nothing was blocked — this is your call" — the choice must be
+knowing, not accidental.
 Step 1 is what makes a lesson safe to keep: a rule about a method has nowhere to put a
 person. But note what that is and is not — it is a discipline, performed by you and
 asserted with `--confirm-method`, which nothing verifies. The property that holds
@@ -501,38 +510,44 @@ Invalid signatures are rejected with confidence `0.0`; they are never a recovera
 4. Extract claims and source URLs.
 5. **Fetch each source through the tool, not by hand:**
    ```python
-   from evidence_fetch import fetch_source, FetchRecord
-   record = fetch_source(url)                      # real HTTP, stdlib only
+   from evidence_fetch import fetch_source_returning_body, FetchRecord
+   from quote_provenance import QuoteRecord, capture_excerpt, write_excerpt
+   record, body = fetch_source_returning_body(url) # real HTTP, captured bytes
    if isinstance(record, FetchRecord):
-       fact = verifier.create_fetched_fact(claim, record, issuer, source_date="2024-03-01")
+       captured = capture_excerpt(body, quoted_text, record)
+       write_excerpt("evidence_excerpts", captured)
+       quoted = QuoteRecord(quoted_text, "raw-fetch", record.final_url,
+                            record.sha256_body, locator, captured["excerpt_id"])
+       fact = verifier.create_fetched_fact(claim, record, issuer, quote=quoted)
    else:                                            # offline, 404, oversize, refused scheme…
        fact = verifier.create_listing_fact(claim, url, reason=record.reason)
    ```
    A claim you never opened a source for is `verifier.create_asserted_fact(claim)` — record it
    honestly and let the gate refuse it. Never hand-label a class you did not earn.
+5a. **When quoting verbatim, capture at fetch time as shown above.** No captured source bytes means
+   no verbatim verdict; `tool-summary` can never earn one even when its words happen to match.
 6. Add facts to the research ledger; issuer-signed facts only when a pinned issuer key actually
    signed the message.
 7. Verify facts and citation chains.
 8. Cross-check claims through ordinary source evaluation.
 9. **Run the report gate before delivering:**
    `python3 scripts/check_report_evidence.py --report <report.md> --facts <facts.json>` — exit 0 required.
+9a. **A NEGATIVE conclusion ("no competitor has this") MUST carry its own basis:** КОРПУС · ПОЛНОТА ·
+   СПОСОБ ПОИСКА · ГРАНИЦА КОРПУСА · СЛЕДСТВИЕ. "We did not find it" is a property of the SEARCH;
+   "it is not there" is a property of the WORLD, and only an exhaustive corpus licenses the second.
+   Form, closed values and the measured reason: `references/negative-results.md`.
 10. Report confidence, evidence-class mix, unsigned claims, rejected signatures, and limitations
     explicitly.
 
 ## Output Expectations
 
-Reports should include:
-
-- Research objective and GOAP plan executed.
-- Findings with source URLs.
-- Verification status per claim on BOTH axes: trust (`ISSUER_SIGNED` / `SELF_ATTESTED` /
-  `UNVERIFIED`) and evidence (`FETCH_VERIFIED` / `LISTING_ONLY` / `ASSERTED` / unknown-legacy).
-- The evidence-class mix as a count — the share of `ASSERTED` should be zero.
-- A visible marker next to every `LISTING_ONLY` claim ("source not opened directly — verify").
-- Chain integrity result when citation chains are used.
-- Unsigned and rejected claims.
-- Explicit caveat that cryptographic provenance is not truth verification, and that
-  `FETCH_VERIFIED` means the bytes arrived — not that the source is right.
+Reports include: the objective + executed GOAP plan; findings with source URLs; per-claim status on
+BOTH axes — trust (`ISSUER_SIGNED`/`SELF_ATTESTED`/`UNVERIFIED`) and evidence
+(`FETCH_VERIFIED`/`LISTING_ONLY`/`ASSERTED`/unknown-legacy); the evidence-class mix as a count
+(the `ASSERTED` share should be zero); a visible marker on every `LISTING_ONLY` claim ("source not
+opened directly — verify"); chain integrity when chains are used; unsigned and rejected claims; the
+explicit caveat that cryptographic provenance is not truth verification — `FETCH_VERIFIED` means
+the bytes arrived, not that the source is right.
 
 ## Implementation
 

package/templates/.claude/skills/goap-research-ed25519/references/negative-results.md

@@ -0,0 +1,94 @@
+# Отрицательный вывод: «не нашли» и «доказали, что нет» — разные утверждения
+
+Читается по требованию. В `SKILL.md` из этого файла живёт одна строка-указатель; всё остальное здесь,
+потому что всегда-загружаемый корпус пакета исчерпан, а объём этой темы в него не помещается.
+
+## Отказ, ради которого это написано
+
+Отчёт исследования умеет делать очень сильное утверждение: **«такой функции нет ни у одного из
+конкурентов; ниша свободна»**. На нём основывают продукт. И ровно оно было НЕВИДИМО для аппарата
+доверия.
+
+**ИЗМЕРЕНО 2026-09-01, ТВИН-ТЕСТОМ, а не грепом** (грепу здесь верить нельзя: он находит словарь, а
+не слепоту). `scripts/check_report_evidence.py` шёл ОТ ЛЕДЖЕРА К ОТЧЁТУ — для каждого записанного
+факта искал его употребление в тексте. Два прогона на ОДНОМ леджере, отчёты различаются РОВНО одной
+строкой отрицательного вывода:
+
+```bash
+python3 check_report_evidence.py --report a.md --facts f.json --json > oa.json
+python3 check_report_evidence.py --report b.md --facts f.json --json > ob.json   # b.md = a.md + одна строка
+diff oa.json ob.json      # ДО починки: пусто, оба exit 0
+```
+
+Вывод гейта был БАЙТ В БАЙТ одинаков. То есть ничем не подкреплённое отрицание не могло ни
+увеличить, ни уменьшить число находок: оно было вне области зрения ПО ПОСТРОЕНИЮ, а не по недосмотру.
+Причина простая и структурная: аппарат оценивал только утверждения, у которых ЕСТЬ источник, а у
+отрицания источника нет — в этом и состоит отрицание.
+
+**МЕХАНИЗМ:** «не встретилось» и «доказано, что нет» приходят в отчёте В ОДИНАКОВОЙ ФОРМЕ, и решения
+по ним принимают одинаково. Первое — свойство ПОИСКА. Второе — свойство МИРА. Только второе
+оправдывает продукт, построенный на пустой нише.
+
+## Форма, которую отрицательный вывод обязан нести
+
+Пять полей рядом с утверждением (в пределах 900 знаков — блок, а не приложение):
+
+| Поле | Что отвечает | Закрытые значения |
+|---|---|---|
+| `КОРПУС` | что именно прочитано, ПЕРЕЧНЕМ | свободный текст, но перечислимый |
+| `ПОЛНОТА` | чем является этот перечень | `перечислимо и объявлено исчерпывающим` · `выборка` · `неизвестна` |
+| `СПОСОБ ПОИСКА` | как искали и какими запросами | свободный текст |
+| `ГРАНИЦА КОРПУСА` | по состоянию на когда | свободный текст |
+| `СЛЕДСТВИЕ` | что из этого следует | `не встретилось` · `намеренно отсутствует` |
+
+**Потолок, и он несущий.** `СЛЕДСТВИЕ: намеренно отсутствует` допустимо ТОЛЬКО при
+`ПОЛНОТА: перечислимо и объявлено исчерпывающим`. Выборка и неизвестная полнота поддерживают
+«не встретилось» и ничего сильнее: отсутствие в ЧАСТИ корпуса — отсутствие в ПОИСКЕ, а не в мире.
+
+**Почему пяти полей, а не двух.** Первая редакция требовала только `КОРПУС` и `ПОЛНОТА`. Проверяющая
+модель назвала это самым слабым местом заявки и была ПРАВА: **исчерпывающий ПЕРЕЧЕНЬ не доказывает
+исчерпывающего ПОИСКА**. Двенадцать страниц, прочитанных от корки до корки, всё равно пропустят
+функцию, если это были не те двенадцать — или если в запросе ни разу не прозвучало слово, которым
+её называет сам поставщик. Поэтому в потолок входят также способ поиска, покрытие запросов, отказы
+выборки и временная граница корпуса. Без них сильное «нет» выписывает себе разрешение само.
+
+## Пример
+
+```markdown
+Вывод: массового экспорта нет ни у одного из трёх конкурентов.
+
+КОРПУС: справочные центры A (14 стр.), B (9 стр.), C (11 стр.) — перечень в приложении A
+ПОЛНОТА: выборка — 34 из ~120 страниц; отказ выборки: раздел для партнёров под входом
+СПОСОБ ПОИСКА: полнотекстовый поиск по 6 запросам: «bulk export», «экспорт», «CSV», «API export», «выгрузка», «download all»
+ГРАНИЦА КОРПУСА: по состоянию на 2026-08-30
+СЛЕДСТВИЕ: не встретилось
+```
+
+`СЛЕДСТВИЕ: намеренно отсутствует` в этом примере было бы отвергнуто гейтом: полнота — выборка.
+
+## Чего проверка НЕ решает, и это граница, а не недоделка
+
+**Подходит ли названный корпус ВОПРОСУ.** Второй случай из полевого каталога ровно об этом: вопрос
+«есть ли у продукта X функция Y», функция описана ТОЛЬКО в справочном центре, а корпусом взята карта
+сайта. Карта сайта — идеально перечислимый, идеально исчерпывающий и НЕ ТОТ корпус. Проверка
+заставляет корпус НАЗВАТЬ, чтобы человек мог судить о его пригодности; судить — не её работа, и
+делать вид, что её, значило бы то самое ложное закрытие класса, которое весь гейт и отвергает.
+
+## Ворота
+
+Отдельного вызова не нужно: проверка живёт внутри уже существующего гейта и ходит во ВТОРУЮ сторону —
+от отрицательных выводов отчёта к их обоснованию.
+
+```bash
+python3 .claude/skills/goap-research-ed25519/scripts/check_report_evidence.py \
+  --report report.md --facts facts.json --json
+```
+
+Виды находок: `NEGATIVE_CONCLUSION_WITHOUT_BASIS` (нет одного из пяти полей — перечисляются, каких) ·
+`NEGATIVE_COMPLETENESS_UNRECOGNISED` · `NEGATIVE_IMPLICATION_UNRECOGNISED` ·
+`NEGATIVE_CLAIM_EXCEEDS_ITS_CEILING` (сильное следствие на выборке).
+
+**Область срабатывания сужена намеренно.** Ловятся УНИВЕРСАЛЬНЫЕ отрицания («ни у одного», «none of
+the», «ниша свободна»), а не любое «нет» в тексте: жадный сторож — не более строгий сторож, а
+сторож, который удалят. Новая формулировка отрицания будет пропущена, и здесь это сказано вслух,
+ровно как соседний пояс по относительному риску говорит о себе то же самое.

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

@@ -11,7 +11,7 @@ evidence axis is lost if "don't include unread claims" stays a sentence in
 SKILL.md that a tired model skips at 2am.
 
 Usage:
-    python3 check_report_evidence.py --report report.md --facts facts.json [--json]
+    python3 check_report_evidence.py --report report.md --facts facts.json [--excerpts DIR] [--json]
 
 Exit codes:
     0  clean — no ASSERTED used, every used LISTING_ONLY carries a marker
@@ -30,11 +30,14 @@ from __future__ import annotations
 
 import argparse
 import json
+import os
 import re
 import sys
 from dataclasses import dataclass
 from typing import Any, Dict, List, Mapping, Optional, Sequence, Tuple
 
+import quote_provenance as quote_provenance
+
 EVIDENCE_FETCH_VERIFIED = "FETCH_VERIFIED"
 EVIDENCE_LISTING_ONLY = "LISTING_ONLY"
 EVIDENCE_ASSERTED = "ASSERTED"
@@ -56,6 +59,17 @@ LISTING_MARKERS = (
 # does not warn the reader of a sentence on page 2.
 MARKER_WINDOW_CHARS = 400
 
+# Report quotes are paired to a fact through the existing generous claim scanner,
+# but the verdict itself is an exact normalized comparison in quote_provenance.
+# Keeping those two polarities separate is load-bearing: generosity is safe for
+# finding a claim and unsafe for granting "verbatim".
+QUOTE_MIN_SIGNIFICANT_CHARS = 15
+QUOTE_PATTERNS = (
+    re.compile(r'«([^»\n]+)»', re.UNICODE),
+    re.compile(r'"([^"\n]+)"', re.UNICODE),
+    re.compile(r'„([^“\n]+)“', re.UNICODE),
+)
+
 # ---------------------------------------------------------------------------
 # SLICE C ADDITIONS (ADR-001 §5, ADR-002 §3) — ADDITIVE ONLY.
 # No existing constant, rule, threshold or exit path above or below is modified:
@@ -370,6 +384,118 @@ def evaluate(report_text: str, facts: Sequence[Dict[str, Any]]) -> Tuple[List[Fi
     return findings, counts
 
 
+def _quoted_spans(report_text: str) -> List[Tuple[str, int, int]]:
+    spans: List[Tuple[str, int, int]] = []
+    occupied: List[Tuple[int, int]] = []
+    for pattern in QUOTE_PATTERNS:
+        for match in pattern.finditer(report_text):
+            start, end = match.span(1)
+            if any(left <= start < right or left < end <= right for left, right in occupied):
+                continue
+            span = match.group(1).strip()
+            significant = len(re.sub(r"[^\w\d]", "", span, flags=re.UNICODE))
+            if significant < QUOTE_MIN_SIGNIFICANT_CHARS:
+                continue
+            occupied.append(match.span(0))
+            spans.append((span, start, end))
+    return sorted(spans, key=lambda item: item[1])
+
+
+def _quote_finding_kind(verdict: str) -> str:
+    if verdict == "not-in-excerpt":
+        return "QUOTE_NOT_IN_SOURCE"
+    if verdict == "method-ineligible":
+        return "QUOTE_METHOD_INELIGIBLE"
+    return "QUOTE_NO_EXCERPT"
+
+
+def evaluate_quotes(
+    report_text: str,
+    facts: Sequence[Dict[str, Any]],
+    excerpt_dir: str,
+) -> Tuple[List[Finding], Dict[str, int]]:
+    """Grade report quotations only from captured excerpt bytes, never metadata.
+
+    ``claim_positions`` is deliberately used only to associate report text with a
+    fact. Its word-overlap fallback NEVER reaches ``verify_verbatim``: the latter
+    performs the exact normalized substring comparison that alone can confirm.
+    """
+    findings: List[Finding] = []
+    counts = {f"quote-{verdict}": 0 for verdict in quote_provenance.VERBATIM_VERDICTS}
+    counts.update({f"quote-acquisition-{method}": 0 for method in quote_provenance.ACQUISITION_METHODS})
+    counts["quote-acquisition-unknown"] = 0
+    counts["quote-total"] = 0
+    counts["quote-unchecked"] = 0
+    spans = _quoted_spans(report_text)
+    seen_pairs = set()
+
+    for fact_index, fact in enumerate(facts):
+        recorded_quote = fact.get("quote")
+        if not isinstance(recorded_quote, str) or not recorded_quote.strip():
+            continue
+        acquisition = quote_provenance.read_acquisition(fact.get("acquisition"))
+        claim = str(fact.get("claim", ""))
+        positions = claim_positions(report_text, claim) or claim_positions(report_text, recorded_quote)
+        normalized_recorded = quote_provenance.normalize_text(recorded_quote)
+        candidates = [
+            (span, start, end) for span, start, end in spans
+            if quote_provenance.normalize_text(span) == normalized_recorded
+            and any(abs(start - position) <= MARKER_WINDOW_CHARS for position in positions)
+        ]
+        for span, start, _ in candidates:
+            pair = (fact_index, start)
+            if pair in seen_pairs:
+                continue
+            seen_pairs.add(pair)
+            counts["quote-total"] += 1
+            method_key = (
+                f"quote-acquisition-{acquisition}"
+                if acquisition in quote_provenance.ACQUISITION_METHODS
+                else "quote-acquisition-unknown"
+            )
+            counts[method_key] += 1
+            locator = fact.get("locator") or "(no locator)"
+            source_url = str(fact.get("source_url", ""))
+
+            try:
+                schema_version = int(fact.get("schema_version"))
+            except (TypeError, ValueError):
+                schema_version = 0
+            if schema_version < 4:
+                verdict = quote_provenance.METHOD_UNKNOWN if acquisition == quote_provenance.METHOD_UNKNOWN else "no-excerpt"
+                counts[f"quote-{verdict}"] += 1
+                findings.append(Finding(
+                    kind="QUOTE_NO_EXCERPT", claim=span, source_url=source_url,
+                    detail=(f"quote {span!r} at {locator} is carried by schema v{schema_version or 'unknown'}; "
+                            "quote provenance is not inside its signed message, so verbatim is unverified")))
+                continue
+
+            try:
+                excerpt_rec = quote_provenance.load_excerpt(excerpt_dir, fact.get("excerpt_id"))
+            except quote_provenance.ExcerptStoreError as exc:
+                counts["quote-unchecked"] += 1
+                findings.append(Finding(
+                    kind="QUOTES_UNCHECKED", claim=span, source_url=source_url,
+                    detail=f"quote {span!r} at {locator} could not be checked: {exc}"))
+                continue
+
+            verdict = quote_provenance.verify_verbatim(span, excerpt_rec, fact)
+            counts[f"quote-{verdict}"] += 1
+            if verdict == "verbatim-confirmed":
+                continue
+            reason = {
+                "not-in-excerpt": "is absent from the single stored excerpt leaf; joining excerpts is forbidden",
+                "no-excerpt": "has no decodable captured excerpt",
+                "method-ineligible": f"uses acquisition method {acquisition!r}, whose ceiling forbids verbatim regardless of content",
+                "hash-mismatch": "has an excerpt/body/source hash mismatch; author-constructed material grants nothing",
+                quote_provenance.METHOD_UNKNOWN: "has an absent or unknown acquisition method; legacy method-unknown never grants verbatim",
+            }[verdict]
+            findings.append(Finding(
+                kind=_quote_finding_kind(verdict), claim=span, source_url=source_url,
+                detail=f"quote {span!r} at {locator} {reason} (verdict: {verdict})"))
+    return findings, counts
+
+
 # ---------------------------------------------------------------------------
 # SLICE C — population applicability (ADR-001 §5) and the relative-risk belt
 # (ADR-002 §3). New functions; nothing above is rewritten.
@@ -561,6 +687,209 @@ def evaluate_population(report_text: str, facts: Sequence[Dict[str, Any]],
     return findings, counts
 
 
+# ---------------------------------------------------------------------------
+# NEGATIVE CONCLUSIONS — the SECOND DIRECTION.
+#
+# Everything above this line walks FROM THE LEDGER TO THE REPORT: for each recorded
+# fact, is it used, and is its use honest? That direction is structurally blind to a
+# claim that HAS NO SOURCE — and the strongest claim a research report can make is
+# exactly that shape: "no competitor has this; the niche is free."
+#
+# MEASURED on this package, 2026-09-01, by TWIN TEST rather than by grep (grep is not
+# trustworthy here — it finds the vocabulary, not the blindness): two runs over ONE
+# ledger, the reports differing by EXACTLY one line, that line being an unsupported
+# negative conclusion. The gate's `--json` output was BYTE-IDENTICAL, both exit 0. So
+# an unbacked negation can neither raise nor lower the finding count: it is outside
+# the field of view by construction, not by oversight.
+#
+# THE MECHANISM: "we did not find it" and "we proved it is not there" arrive in the
+# report in the SAME FORM, and decisions are made on both identically. The first is a
+# property of the SEARCH. The second is a property of the WORLD. Only the second
+# justifies building a product on an empty niche.
+#
+# THE CEILING, and why the obvious version of it is not enough. The first design said
+# a negative conclusion needs an enumerable CORPUS declared exhaustive. A reviewing
+# model called that the weakest part of the proposal and was RIGHT: an exhaustive LIST
+# does not prove an exhaustive SEARCH. Twelve pages read end-to-end still miss the
+# feature if the twelve were the wrong twelve, or if the query never used the vendor's
+# word for it. So the ceiling also requires the SEARCH METHOD, the QUERY COVERAGE, the
+# SAMPLING REFUSALS, and the corpus's TIME BOUNDARY. Without those, a strong "no"
+# writes itself a licence.
+#
+# WHAT THIS SCAN CANNOT DECIDE, stated here and printed in the gate's output: whether
+# the named corpus is the RIGHT corpus for the question. The record's own second case
+# is exactly that — "does product X have feature Y", where the feature is documented
+# only in the help centre and the corpus taken was the sitemap. A sitemap is a
+# perfectly enumerable, perfectly exhaustive corpus, and the wrong one. This scan
+# forces the corpus to be NAMED so a person can judge its fitness; judging it stays
+# layer 3, and pretending otherwise would be the same false closure the whole gate
+# exists to refuse.
+# ---------------------------------------------------------------------------
+
+# A NEGATIVE UNIVERSAL claim: absence asserted across a whole population of products,
+# vendors or sources. Deliberately narrower than "any negation" — `there is no` alone
+# fires on ordinary prose, and an eager gate is not a stricter gate, it is a deleted
+# one. Every pattern here requires the UNIVERSAL, which is what makes the claim strong.
+NEGATIVE_CLAIM_PATTERNS = (
+    r"ни\s+у\s+одного",
+    r"ни\s+один\s+из\s+[^.\n]{0,60}?\s+не\b",
+    r"ни\s+одного\s+из",
+    r"нет\s+ни\s+у\s+кого",
+    r"ниша\s+свободна",
+    r"никто\s+(?:из\s+\w+\s+)?не\s+(?:предлагает|поддерживает|делает|умеет)",
+    r"отсутствует\s+у\s+всех",
+    r"no\s+(?:competitor|vendor|provider|product|tool)s?\s+\w*\s*(?:has|have|offers?|supports?|provides?)",
+    r"none\s+of\s+the\s+\w+\s+(?:has|have|offer|offers|support|supports|provide|provides)",
+    r"nobody\s+(?:offers|supports|provides)",
+    r"the\s+niche\s+is\s+(?:free|open|unoccupied)",
+    r"we\s+found\s+no\s+\w+\s+(?:that|which)",
+)
+
+# The block that licenses such a claim. Both spellings, because a report may be written
+# in either language; the fields must be VISIBLE to a reader, never a hidden attribute.
+NEGATIVE_FIELDS = (
+    ("corpus", ("КОРПУС", "CORPUS")),
+    ("completeness", ("ПОЛНОТА", "COMPLETENESS")),
+    ("method", ("СПОСОБ ПОИСКА", "SEARCH METHOD")),
+    ("boundary", ("ГРАНИЦА КОРПУСА", "CORPUS AS OF")),
+    ("implication", ("СЛЕДСТВИЕ", "IMPLICATION")),
+)
+
+# How far from the claim the licensing block may sit. Wider than MARKER_WINDOW_CHARS
+# because this is a five-line block rather than a parenthetical, and narrower than the
+# document because a basis in the appendix does not reach a sentence on page 2.
+NEGATIVE_WINDOW_CHARS = 900
+
+# CLOSED. Three, because collapsing them would erase the only distinction that matters:
+# an enumerated corpus its own author calls complete is a different epistemic object
+# from a sample, and both differ from not knowing which you have.
+COMPLETENESS_VALUES = {
+    "перечислимо и объявлено исчерпывающим": "exhaustive",
+    "enumerable and declared exhaustive": "exhaustive",
+    "выборка": "sample",
+    "sample": "sample",
+    "неизвестна": "unknown",
+    "unknown": "unknown",
+}
+
+# CLOSED, and the whole point of the feature is that these two are not interchangeable.
+IMPLICATION_VALUES = {
+    "не встретилось": "not-encountered",
+    "not encountered": "not-encountered",
+    "намеренно отсутствует": "deliberately-absent",
+    "deliberately absent": "deliberately-absent",
+}
+
+
+def _negative_field(window: str, spellings: Sequence[str]) -> Optional[str]:
+    """The value of one licensing field inside the window, or None when it is absent.
+
+    An EMPTY value returns '' and is never collapsed into absent: "КОРПУС:" with
+    nothing after it is a different mistake from no КОРПУС line at all, and the two
+    need different repairs.
+    """
+    for spelling in spellings:
+        match = re.search(
+            r"^[\s>*\-]*(?:\*\*)?" + re.escape(spelling) + r"(?:\*\*)?\s*[:：]\s*(.*)$",
+            window, re.IGNORECASE | re.MULTILINE | re.UNICODE)
+        if match:
+            return match.group(1).strip().strip("*`")
+    return None
+
+
+def _closed_value(raw: Optional[str], table: Mapping[str, str]) -> Optional[str]:
+    """Map a field value onto a CLOSED vocabulary, matching on the leading phrase so a
+    author may add detail after it — `выборка — 12 из ~40 страниц` is a sample that
+    says how big, which is better than a bare word and must not be refused for it."""
+    if raw is None:
+        return None
+    lowered = raw.strip().lower()
+    for key, value in table.items():
+        if lowered == key or lowered.startswith(key + " ") or lowered.startswith(key + ",") \
+                or lowered.startswith(key + " —") or lowered.startswith(key + " -") \
+                or lowered.startswith(key + ":"):
+            return value
+    return "unrecognised"
+
+
+def scan_negative_conclusions(report_text: str) -> List[Finding]:
+    """The second direction: from the report's NEGATIVE conclusions back to their basis.
+
+    A claim of universal absence must carry, within its window, the five fields that
+    distinguish a property of the SEARCH from a property of the WORLD — and the strong
+    implication (`намеренно отсутствует`) is admissible only on top of an exhaustive
+    corpus, because an exhaustive list is not an exhaustive search.
+
+    HONEST SCOPE: this matches CLAIM SHAPES and FIELD PRESENCE. It cannot tell whether
+    the named corpus fits the question — a sitemap is enumerable, exhaustive and the
+    wrong place to look for a feature. Naming the corpus is what makes that arguable;
+    judging it is not this gate's to do.
+    """
+    findings: List[Finding] = []
+    seen_spans: List[Tuple[int, int]] = []
+    for pattern in NEGATIVE_CLAIM_PATTERNS:
+        for hit in re.finditer(pattern, report_text, re.IGNORECASE | re.UNICODE):
+            # One sentence, one finding: two patterns matching the same claim describe
+            # one defect, and reporting it twice would inflate the count the twin test
+            # measures.
+            if any(start <= hit.start() < end for start, end in seen_spans):
+                continue
+            line_start = report_text.rfind("\n", 0, hit.start()) + 1
+            line_end = report_text.find("\n", hit.end())
+            line_end = len(report_text) if line_end < 0 else line_end
+            seen_spans.append((line_start, line_end))
+            claim = report_text[line_start:line_end].strip()
+
+            window = report_text[max(0, hit.start() - NEGATIVE_WINDOW_CHARS):
+                                 min(len(report_text), hit.end() + NEGATIVE_WINDOW_CHARS)]
+            values = {name: _negative_field(window, spellings) for name, spellings in NEGATIVE_FIELDS}
+            missing = [spellings[0] for name, spellings in NEGATIVE_FIELDS
+                       if values[name] is None or values[name] == ""]
+            if missing:
+                findings.append(Finding(
+                    kind="NEGATIVE_CONCLUSION_WITHOUT_BASIS", claim=claim, source_url="",
+                    detail=("a claim of universal ABSENCE with no basis beside it — missing: {m}. "
+                            "'we did not find it' and 'we proved it is not there' are written the "
+                            "same way and decided on identically; the first is a property of the "
+                            "SEARCH, the second of the WORLD. Required within {w} chars: {req}"
+                            .format(m=", ".join(missing), w=NEGATIVE_WINDOW_CHARS,
+                                    req=", ".join(s[0] for _, s in NEGATIVE_FIELDS)))))
+                continue
+
+            completeness = _closed_value(values["completeness"], COMPLETENESS_VALUES)
+            implication = _closed_value(values["implication"], IMPLICATION_VALUES)
+            if completeness == "unrecognised":
+                findings.append(Finding(
+                    kind="NEGATIVE_COMPLETENESS_UNRECOGNISED", claim=claim, source_url="",
+                    detail=("ПОЛНОТА is {v!r}, which is outside the closed set {allowed}. An open "
+                            "field here collects a word that sounds thorough and commits to nothing"
+                            .format(v=values["completeness"],
+                                    allowed=sorted(set(COMPLETENESS_VALUES.values()))))))
+                continue
+            if implication == "unrecognised":
+                findings.append(Finding(
+                    kind="NEGATIVE_IMPLICATION_UNRECOGNISED", claim=claim, source_url="",
+                    detail=("СЛЕДСТВИЕ is {v!r}, which is outside the closed set {allowed}. These "
+                            "two are exactly what must not be interchangeable"
+                            .format(v=values["implication"],
+                                    allowed=sorted(set(IMPLICATION_VALUES.values()))))))
+                continue
+
+            # THE CEILING, and the correction that made this record worth shipping: the
+            # strong reading needs an exhaustive corpus UNDER it. A sample can support
+            # "we did not encounter it" and can never support "it is deliberately absent".
+            if implication == "deliberately-absent" and completeness != "exhaustive":
+                findings.append(Finding(
+                    kind="NEGATIVE_CLAIM_EXCEEDS_ITS_CEILING", claim=claim, source_url="",
+                    detail=("СЛЕДСТВИЕ 'намеренно отсутствует' rests on ПОЛНОТА {c!r}. A sample — or "
+                            "an unknown completeness — supports 'не встретилось' and nothing "
+                            "stronger: absence in part of a corpus is absence from the SEARCH, not "
+                            "from the world. Lower the implication, or make the corpus enumerable "
+                            "and declare it exhaustive"
+                            .format(c=values["completeness"]))))
+    return findings
+
+
 def scan_relative_risk(report_text: str) -> List[Finding]:
     """BELT (D-19): refuse a relative figure with no absolute companion in the window.
 
@@ -619,6 +948,30 @@ def render_population_and_risk(counts: Dict[str, int], profile_supplied: bool) -
     return "\n".join(lines)
 
 
+def render_quotes(counts: Dict[str, int]) -> str:
+    """One compact, auditable line for the independent quote-verdict axis."""
+    return (
+        "  quotes: {total} checked — confirmed {confirmed} / absent {absent} / no-excerpt {missing} / "
+        "method-ineligible {ineligible} / hash-mismatch {mismatch} / method-unknown {unknown} / "
+        "unchecked {unchecked}; methods raw-fetch {raw} / tool-summary {tool} / search-listing {search} / "
+        "manual {manual} / unknown {method_unknown}"
+    ).format(
+        total=counts.get("quote-total", 0),
+        confirmed=counts.get("quote-verbatim-confirmed", 0),
+        absent=counts.get("quote-not-in-excerpt", 0),
+        missing=counts.get("quote-no-excerpt", 0),
+        ineligible=counts.get("quote-method-ineligible", 0),
+        mismatch=counts.get("quote-hash-mismatch", 0),
+        unknown=counts.get("quote-method-unknown", 0),
+        unchecked=counts.get("quote-unchecked", 0),
+        raw=counts.get("quote-acquisition-raw-fetch", 0),
+        tool=counts.get("quote-acquisition-tool-summary", 0),
+        search=counts.get("quote-acquisition-search-listing", 0),
+        manual=counts.get("quote-acquisition-manual", 0),
+        method_unknown=counts.get("quote-acquisition-unknown", 0),
+    )
+
+
 def render(findings: Sequence[Finding], counts: Dict[str, int]) -> str:
     lines: List[str] = []
     total = sum(counts.values())
@@ -649,7 +1002,9 @@ def render(findings: Sequence[Finding], counts: Dict[str, int]) -> str:
         "  scope: proves the report does not lean on unread sources AND that the ledger's evidence "
         "classes carry intact signatures. It does NOT prove the cited sources support the claims, "
         "and it can only judge claims it recognises as used — paraphrase detection is deliberately "
-        "over-eager, because a missed unread claim is silent while a false alarm is arguable."
+        "over-eager, because a missed unread claim is silent while a false alarm is arguable. "
+        "Negative conclusions are judged in the OTHER direction, from the claim back to its basis; "
+        "that scan proves the basis is STATED, never that the named corpus fits the question."
     )
     return "\n".join(lines)
 
@@ -660,6 +1015,10 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     parser.add_argument("--facts", required=True, help="path to facts.json")
     parser.add_argument("--json", action="store_true", help="emit machine-readable JSON")
     parser.add_argument("--pins", help="JSON file of {issuer: pubkey_b64} so ISSUER_SIGNED facts can be checked")
+    parser.add_argument(
+        "--excerpts",
+        help="captured excerpt directory (default: evidence_excerpts beside the facts ledger)",
+    )
     # SLICE C: OPTIONAL on purpose. Making it mandatory would break every documented
     # invocation for a check that cannot always apply; letting its absence pass
     # silently would be "inconclusive reads as pass". Its absence is PRINTED instead.
@@ -695,13 +1054,17 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     # SLICE C: three independent judgements merged into the SAME findings list — the
     # merge must not lose one, and the existing exit path below is unchanged.
     population_findings, population_counts = evaluate_population(report_text, facts, profile)
-    findings = findings + population_findings + scan_relative_risk(report_text)
+    findings = (findings + population_findings + scan_relative_risk(report_text)
+                + scan_negative_conclusions(report_text))
+    excerpt_dir = args.excerpts or os.path.join(os.path.dirname(os.path.abspath(args.facts)), "evidence_excerpts")
+    quote_findings, quote_counts = evaluate_quotes(report_text, facts, excerpt_dir)
+    findings += quote_findings
     if args.json:
         print(
             json.dumps(
                 {
                     "ok": not findings,
-                    "counts": dict(counts, **population_counts),
+                    "counts": dict(counts, **population_counts, **quote_counts),
                     "populationChecked": profile is not None,
                     "findings": [f.__dict__ for f in findings],
                     "exitCode": 1 if findings else 0,
@@ -712,6 +1075,7 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
     else:
         print(render(findings, counts))
         print(render_population_and_risk(population_counts, profile is not None))
+        print(render_quotes(quote_counts))
     return 1 if findings else 0