postmo 1.0.0__tar.gz → 1.2.0__tar.gz

{postmo-1.0.0/src/postmo.egg-info → postmo-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: postmo
-Version: 1.0.0
+Version: 1.2.0
 Summary: Hold a messy multi-person situation without resolving it: five audit disciplines as linter checks plus a full structured audit record.
 Author: Ryan Wesley Hitchcock
 License: MIT

{postmo-1.0.0 → postmo-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "postmo"
-version = "1.0.0"
+version = "1.2.0"
 description = "Hold a messy multi-person situation without resolving it: five audit disciplines as linter checks plus a full structured audit record."
 readme = "README.md"
 license = { text = "MIT" }

{postmo-1.0.0 → postmo-1.2.0}/src/postmo/__init__.py

@@ -28,10 +28,11 @@ from .record import (
     utc_now,
 )
 from .scans import (
-    Correction, CorrectionCandidate, HeldTension, MotiveFlag, PersonState,
-    ScanError, ScanReport, SofteningFlag, VerdictWordHit,
-    detect_softening, detect_supplied_motive, find_correction_candidates,
-    find_subordinators, find_verdict_words, scan_text,
+    Correction, CorrectionCandidate, CorrectionCoverage, HeldTension,
+    MotiveFlag, PersonState, ScanError, ScanReport, SofteningFlag,
+    SofteningResult, VerdictWordHit, correction_coverage, detect_softening,
+    detect_supplied_motive, find_correction_candidates, find_subordinators,
+    find_verdict_words, render_correction_coverage, scan_text,
 )
 
 __all__ = [
@@ -41,9 +42,10 @@ __all__ = [
     "NEVER", "attachment_for", "describe_contract",
     "PROTOCOL", "AuditRecord", "DisciplineEntry", "RecordError",
     "check_stand_down", "parse", "utc_now",
-    "Correction", "CorrectionCandidate", "HeldTension", "MotiveFlag",
-    "PersonState", "ScanError", "ScanReport", "SofteningFlag",
-    "VerdictWordHit", "detect_softening", "detect_supplied_motive",
+    "Correction", "CorrectionCandidate", "CorrectionCoverage",
+    "HeldTension", "MotiveFlag", "PersonState", "ScanError", "ScanReport",
+    "SofteningFlag", "SofteningResult", "VerdictWordHit",
+    "correction_coverage", "detect_softening", "detect_supplied_motive",
     "find_correction_candidates", "find_subordinators", "find_verdict_words",
-    "scan_text",
+    "render_correction_coverage", "scan_text",
 ]

{postmo-1.0.0 → postmo-1.2.0}/src/postmo/record.py

@@ -238,19 +238,50 @@ def _section_text(rendered: str, key: str) -> str:
     if not match:
         return ""
     tail = rendered[match.end():]
+    # Consume the rest of the heading line (" (discipline 1)" etc.) —
+    # it is heading, not section content.
+    newline = tail.find("\n")
+    tail = tail[newline + 1:] if newline != -1 else ""
     next_heading = re.search(r"^## ", tail, re.MULTILINE)
     return tail[: next_heading.start()] if next_heading else tail
 
 
+def _deviations(rendered: str) -> list[str]:
+    """Non-schema lines inside record sections.
+
+    PARAM-POSTMO-013: a line inside a section that is neither blank nor
+    a "- " schema item is a deviation — the canonical archive must not
+    eat its own marginalia. Returns "section: line N: 'content'" strings.
+    """
+    found: list[str] = []
+    for key in _SECTION_RES:
+        for lineno, line in enumerate(
+                _section_text(rendered, key).splitlines(), 1):
+            if line.strip() and not line.startswith("- "):
+                found.append(f"{key}: line {lineno}: {line.strip()!r}")
+    return found
+
+
 def parse(rendered: str) -> AuditRecord:
     """Parse a rendered record back into an AuditRecord.
 
     Round-trip fidelity: case name, lifecycle, date, and every
     structured section survive. Items re-validate on the way in —
     a hand-edited record with a subordinating tension or a bad tag
-    fails here, not silently.
+    fails here, not silently. PARAM-POSTMO-013: parse() is loud about
+    non-schema lines — a hand annotation inside a section is rejected
+    (RecordError naming the line), never silently swallowed.
     """
     check_stand_down(rendered)
+    deviations = _deviations(rendered)
+    if deviations:
+        raise RecordError(
+            "Non-schema lines inside record sections "
+            f"({len(deviations)}):\n"
+            + "\n".join(f"  - {d}" for d in deviations)
+            + "\nparse() does not swallow marginalia — move hand "
+            "annotations to the Evidence section as '- [tag] text' items."
+        )
     front = dict(
         line.split(":", 1)
         for line in rendered.splitlines()

{postmo-1.0.0 → postmo-1.2.0}/src/postmo/scans.py

@@ -20,6 +20,7 @@ disagree. See README "Overlap with evasion_audit".
 from __future__ import annotations
 
 import re
+from collections.abc import Iterable
 from dataclasses import dataclass, field
 
 
@@ -183,18 +184,139 @@ class CorrectionCandidate:
     marker: str
 
 
+def _marker_for(sentence: str) -> str:
+    """First correction marker found in the sentence, or "".
+
+    Shared with find_correction_candidates so the two can't drift.
+    """
+    lowered = sentence.lower()
+    return next((m for m in CORRECTION_MARKERS if m in lowered), "")
+
+
+def _norm(text: str) -> str:
+    """Match key for operator-typed text: stripped, case-folded."""
+    return text.strip().casefold()
+
+
 def find_correction_candidates(text: str) -> list[CorrectionCandidate]:
     """Flag correction-like sentences that need typing (D3, operator step)."""
     found: list[CorrectionCandidate] = []
     for sentence in sentences(text):
-        lowered = sentence.lower()
-        for marker in CORRECTION_MARKERS:
-            if marker in lowered:
-                found.append(CorrectionCandidate(sentence=sentence, marker=marker))
-                break
+        marker = _marker_for(sentence)
+        if marker:
+            found.append(CorrectionCandidate(sentence=sentence, marker=marker))
     return found
 
 
+@dataclass(frozen=True)
+class CorrectionCoverage:
+    """One sentence's typing status, published in the final report.
+
+    PARAM-POSTMO-002: typing stays human, but the untyped becomes
+    visible. status "typed": the operator typed this sentence (kind
+    recorded). status "candidate": a marker fired but the operator did
+    not type it — the reader sees the choice not to type. status
+    "unmarked": no marker fired, so it was never surfaced for typing.
+    status "unmatched": a typed Correction whose text matches no
+    sentence of the text — surfaced, never silently dropped.
+    marker: the correction marker found in the sentence, when any.
+    """
+
+    sentence: str
+    status: str  # "typed" | "candidate" | "unmarked" | "unmatched"
+    kind: str = ""  # "detail" | "core-claim", when typed or unmatched
+    marker: str = ""  # the marker that fired, when any
+
+    def __post_init__(self) -> None:
+        if self.status not in ("typed", "candidate", "unmarked", "unmatched"):
+            raise ScanError(f"Bad coverage status: {self.status!r}.")
+        if self.status in ("typed", "unmatched") \
+                and self.kind not in CORRECTION_KINDS:
+            raise ScanError(
+                f"Typed coverage needs a correction kind, got {self.kind!r}."
+            )
+        if not self.sentence.strip():
+            raise ScanError("Coverage row needs the sentence.")
+
+
+def correction_coverage(
+    text: str, typed: Iterable[Correction] = ()
+) -> list[CorrectionCoverage]:
+    """Typing-coverage audit for the final report (D3, PARAM-POSTMO-002).
+
+    Publishes every sentence with its typing status — marked, unmarked,
+    typed, untyped — so readers see what the operator chose not to
+    type. `typed` is the operator's typed Corrections; a Correction
+    matches a sentence when its text matches the sentence after
+    stripping and case-folding. A typed Correction whose text matches no
+    sentence is appended with status "unmatched" — surfaced, never
+    silently dropped. Duplicate typed Corrections for one sentence:
+    the first wins. `typed` may be any iterable (generators included) —
+    it is materialized once up front.
+    """
+    typed = list(typed)
+    typed_by_text: dict[str, str] = {}
+    for correction in typed:
+        typed_by_text.setdefault(_norm(correction.text), correction.kind)
+    rows: list[CorrectionCoverage] = []
+    matched: set[str] = set()
+    for sentence in sentences(text):
+        marker = _marker_for(sentence)
+        key = _norm(sentence)
+        if key in typed_by_text:
+            matched.add(key)
+            rows.append(CorrectionCoverage(
+                sentence=sentence, status="typed",
+                kind=typed_by_text[key], marker=marker,
+            ))
+        elif marker:
+            rows.append(CorrectionCoverage(
+                sentence=sentence, status="candidate", marker=marker,
+            ))
+        else:
+            rows.append(CorrectionCoverage(sentence=sentence, status="unmarked"))
+    for correction in typed:
+        key = _norm(correction.text)
+        if key not in matched:
+            matched.add(key)
+            rows.append(CorrectionCoverage(
+                sentence=correction.text.strip(), status="unmatched",
+                kind=correction.kind,
+            ))
+    return rows
+
+
+def render_correction_coverage(
+    text: str, typed: Iterable[Correction] = ()
+) -> str:
+    """Render the D3 typing-coverage section for the final report.
+
+    One line per sentence: its typing status, the kind when typed, and
+    the marker when one fired. Untyped candidates and unmarked
+    sentences are published, not hidden — typing-coverage is auditable.
+    Typed corrections matching no sentence get their own section.
+    """
+    lines = ["## Correction typing coverage (discipline 3)"]
+    unmatched: list[CorrectionCoverage] = []
+    for row in correction_coverage(text, typed):
+        if row.status == "unmatched":
+            unmatched.append(row)
+            continue
+        marker = f" (marker: {row.marker!r})" if row.marker else ""
+        if row.status == "typed":
+            lines.append(f"- [typed: {row.kind}]{marker} {row.sentence}")
+        elif row.status == "candidate":
+            lines.append(f"- [untyped candidate]{marker} {row.sentence}")
+        else:
+            lines.append(f"- [unmarked] {row.sentence}")
+    if unmatched:
+        lines.append("")
+        lines.append("## Typed corrections not found in the text")
+        for row in unmatched:
+            lines.append(f"- [unmatched: {row.kind}] {row.sentence}")
+    return "\n".join(lines)
+
+
 # --- Discipline 4: supplied-motive detection -----------------------------------
 
 # Attributions that make a motive/causal claim legitimate — the teller
@@ -227,8 +349,31 @@ MOTIVE_PATTERNS = (
 )
 
 _MOTIVE_RES = tuple(re.compile(p, re.IGNORECASE) for p in MOTIVE_PATTERNS)
+
+# Speech verbs that pair with a quote to form attribution context.
+# PARAM-POSTMO-014: a bare double-quote alone is NOT attribution — scare
+# quotes must not pass as sourcing. Quoted material counts as attributed
+# only with a recognizable source: an attribution marker, or a speech
+# verb in a dialogue tag directly beside the quote (", she said" /
+# "she said, "). "Adjacent" is deliberately tight — a verb in another
+# clause ("when the witness said") does not attribute the quote. A miss
+# here fails toward a flag, and a flag is a REVIEW item: the operator
+# decides, which is the safe direction for an audit tripwire.
+_QUOTE_VERBS = (
+    "said", "stated", "told", "asked", "replied", "answered",
+    "explained", "claimed", "admitted", "insisted", "recalled",
+    "described", "reported", "wrote", "shouted", "whispered", "muttered",
+    "quotes", "quoted",
+)
+_VERB_ALT = "|".join(re.escape(v) for v in _QUOTE_VERBS)
+# A dialogue-tag speaker: pronoun, "the <noun>", or a capitalized name
+# (possibly multi-word: "Jane Doe"). Case-sensitive on the name so a
+# lowercase clause word ("when the witness admitted") can't pose as one.
+_SPEAKER = r"(?:he|she|they|i|we|you|the\s+\w+|(?-i:[A-Z])[\w.]*(?:\s+(?-i:[A-Z])[\w.]*)*)"
 _ATTRIBUTION_RE = re.compile(
-    r"\b(" + "|".join(re.escape(m) for m in ATTRIBUTION_MARKERS) + r")\b|\"",
+    r"\b(" + "|".join(re.escape(m) for m in ATTRIBUTION_MARKERS) + r")\b"
+    r"|\b(" + _VERB_ALT + r")\b(?:\s+(?:him|her|them|me|us|it))?[,\s:]{0,6}\""
+    r"|\"[,\s:]{0,6}(?:" + _SPEAKER + r"\s+)?\b(" + _VERB_ALT + r")\b",
     re.IGNORECASE,
 )
 _GUESS_RE = re.compile(
@@ -263,7 +408,9 @@ def detect_supplied_motive(text: str) -> list[MotiveFlag]:
 
     "He tackled you because he panicked" → flag. "He said he panicked"
     → clean (the teller assigned the why). "If I had to guess, he
-    panicked" → guess (allowed, kept marked).
+    panicked" → guess (allowed, kept marked). Scare quotes are not
+    attribution: 'He panicked and "ran"' → flag, while '"He panicked,"
+    she admitted' → clean (quote-adjacent speech verb).
     """
     flags: list[MotiveFlag] = []
     for sentence in sentences(text):
@@ -358,7 +505,31 @@ def _word_present(word: str, text: str) -> bool:
     return re.search(r"\b" + re.escape(word) + r"\b", text, re.IGNORECASE) is not None
 
 
-def detect_softening(original: str, restatement: str) -> list[SofteningFlag]:
+@dataclass(frozen=True)
+class SofteningResult:
+    """Coverage-carrying result of the D5 softening comparison.
+
+    PARAM-POSTMO-016: a bare flags list cannot encode "no tripwire
+    fired" vs "nothing to find" — the result carries its own coverage,
+    so an empty flags list is distinguishable from "text is clean" at
+    the call site. DOWNGRADE_PAIRS stays a closed 1:1 table (the table
+    itself is wont_change); matching semantics untouched.
+
+    Frozen protects field rebinding, not the flags list's contents —
+    treat result.flags as read-only.
+    """
+
+    flags: list[SofteningFlag] = field(default_factory=list)
+    pairs_consulted: int = len(DOWNGRADE_PAIRS)
+    scope_note: str = "closed 1:1 table; off-table synonyms not evaluated"
+    # S8-06 P2 (wont_fix_by_design): the D2 verdict-word scan requires a
+    # copula before the noun ("he's a liar") — bare nominals ("the
+    # manipulator on the team") are not flagged. Disclosed here per the
+    # adjudicated contract rather than removed.
+    grammar_required: str = "copula"
+
+
+def detect_softening(original: str, restatement: str) -> SofteningResult:
     """Compare the teller's words against a restatement (D5).
 
     Catches: strong terms downgraded to soft ones, strong terms dropped
@@ -366,6 +537,10 @@ def detect_softening(original: str, restatement: str) -> list[SofteningFlag]:
     phrases in the restatement. What it cannot catch — generous
     interpretations supplied unasked, evasive answers — stays operator
     protocol (see disciplines.py D5).
+
+    Returns a SofteningResult (PARAM-POSTMO-016), not a bare list — the
+    result carries the coverage (pairs consulted, scope note) so the
+    call site can tell "no flags" apart from "text is clean".
     """
     flags: list[SofteningFlag] = []
     for strong, soft in DOWNGRADE_PAIRS:
@@ -394,7 +569,7 @@ def detect_softening(original: str, restatement: str) -> list[SofteningFlag]:
             kind="ambivalence-resolved",
             detail=f"Restatement resolves ambivalence: {ambivalence.group(0)!r}.",
         ))
-    return flags
+    return SofteningResult(flags=flags)
 
 
 # --- Batch audit: run every mechanical check at once ----------------------------
@@ -407,27 +582,67 @@ class ScanReport:
     verdict_words: list[VerdictWordHit] = field(default_factory=list)
     correction_candidates: list[CorrectionCandidate] = field(default_factory=list)
     motive_flags: list[MotiveFlag] = field(default_factory=list)
-    softening_flags: list[SofteningFlag] = field(default_factory=list)
+    correction_coverage: list[CorrectionCoverage] = field(default_factory=list)
+    # PARAM-POSTMO-016: the D5 softening comparison returns a
+    # coverage-carrying SofteningResult. None = D5 not checked (no
+    # restatement supplied) — "softening not checked" is not "no
+    # softening found" (PARAM-POSTMO-015).
+    softening: SofteningResult | None = None
+
+    @property
+    def softening_flags(self) -> list[SofteningFlag]:
+        """The D5 flags ([] when D5 was not checked). Kept so callers
+        iterating flags directly keep working."""
+        return self.softening.flags if self.softening is not None else []
+
+    @property
+    def softening_checked(self) -> bool:
+        """True when the D5 comparison ran (a restatement was supplied)."""
+        return self.softening is not None
 
     def clean(self) -> bool:
-        """True when no check fired. Not a clean bill of health — see the
-        honesty note at the top of this module."""
-        return not (self.subordinators or self.verdict_words
-                    or self.correction_candidates or self.motive_flags
-                    or self.softening_flags)
+        """True when every check ran and none fired.
+
+        Never true when the D5 softening comparison was not checked —
+        an unchecked D5 is not a clean bill of health (PARAM-POSTMO-015).
+        See the honesty note at the top of this module.
+        """
+        return self.softening is not None and not (
+            self.subordinators or self.verdict_words
+            or self.correction_candidates or self.motive_flags
+            or self.softening.flags
+        )
+
+    def softening_state(self) -> str:
+        """The D5 state, explicit: "not-checked" | "clean" | "flagged"."""
+        if self.softening is None:
+            return "not-checked"
+        return "flagged" if self.softening.flags else "clean"
 
 
-def scan_text(text: str, *, restatement: str = "") -> ScanReport:
+def scan_text(text: str, *, restatement: str = "",
+              typed: Iterable[Correction] = ()) -> ScanReport:
     """Run every mechanical check over `text`.
 
     Pass the auditor's restatement as `restatement` to enable the D5
-    softening comparison. Everything that fires is a REVIEW item for
-    the operator — the scan finds, the operator decides.
+    softening comparison. Without it the D5 check does not run, the
+    report records softening as "not-checked", and clean() is False —
+    an unchecked D5 never reports clean (PARAM-POSTMO-015). Pass the
+    operator's typed Corrections as `typed` to enable the D3
+    typing-coverage report (PARAM-POSTMO-002): typed sentences drop off
+    the candidate list, and the report carries every sentence with its
+    typing status. Everything that fires is a REVIEW item for the
+    operator — the scan finds, the operator decides.
     """
+    typed = list(typed)  # generators are one-shot; materialize once
+    typed_keys = {_norm(c.text) for c in typed}
+    candidates = [c for c in find_correction_candidates(text)
+                  if _norm(c.sentence) not in typed_keys]
     return ScanReport(
         subordinators=find_subordinators(text),
         verdict_words=find_verdict_words(text),
-        correction_candidates=find_correction_candidates(text),
+        correction_candidates=candidates,
         motive_flags=detect_supplied_motive(text),
-        softening_flags=detect_softening(text, restatement) if restatement else [],
+        correction_coverage=correction_coverage(text, typed),
+        softening=detect_softening(text, restatement) if restatement else None,
     )

{postmo-1.0.0 → postmo-1.2.0/src/postmo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: postmo
-Version: 1.0.0
+Version: 1.2.0
 Summary: Hold a messy multi-person situation without resolving it: five audit disciplines as linter checks plus a full structured audit record.
 Author: Ryan Wesley Hitchcock
 License: MIT

{postmo-1.0.0 → postmo-1.2.0}/tests/test_record.py

@@ -128,6 +128,43 @@ class RecordRoundTripTest(unittest.TestCase):
         twice = parse(once.render())
         self.assertEqual(once.render(), twice.render())
 
+    def test_parse_rejects_hand_annotation_in_section(self):
+        rendered = sample_record().render().replace(
+            "## Corrections (discipline 3)\n",
+            "## Corrections (discipline 3)\n"
+            "(hand note: double-check the Tuesday claim)\n",
+        )
+        with self.assertRaises(RecordError) as ctx:
+            parse(rendered)
+        message = str(ctx.exception)
+        self.assertIn("Non-schema lines", message)
+        self.assertIn("double-check the Tuesday claim", message)
+        self.assertIn("Evidence section", message)
+
+    def test_parse_rejects_multiple_deviations_at_once(self):
+        rendered = sample_record().render()
+        rendered = rendered.replace(
+            "## Held tensions (discipline 1)\n",
+            "## Held tensions (discipline 1)\nnote one\n",
+        ).replace(
+            "## Evidence\n",
+            "## Evidence\nnote two\n",
+        )
+        with self.assertRaises(RecordError) as ctx:
+            parse(rendered)
+        message = str(ctx.exception)
+        self.assertIn("(2)", message)
+        self.assertIn("note one", message)
+        self.assertIn("note two", message)
+
+    def test_parse_tolerates_blank_lines_in_sections(self):
+        rendered = sample_record().render().replace(
+            "## Corrections (discipline 3)\n",
+            "## Corrections (discipline 3)\n\n   \n",
+        )
+        rec = parse(rendered)
+        self.assertEqual(len(rec.corrections), 2)
+
 
 def rec_tension_texts():
     return [t.text for t in parse(sample_record().render()).tensions]

postmo-1.2.0/tests/test_scans.py

@@ -0,0 +1,477 @@
+"""Tests for the mechanical linter checks (scans.py) and the discipline table."""
+
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+
+from postmo.disciplines import D1, D2, D3, D4, D5, DISCIPLINES, discipline_name
+
+AUDIT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+from postmo.scans import (
+    DOWNGRADE_PAIRS, Correction, CorrectionCandidate, CorrectionCoverage,
+    HeldTension, MotiveFlag, PersonState, ScanError, ScanReport,
+    SofteningResult, correction_coverage, detect_softening,
+    detect_supplied_motive, find_correction_candidates, find_subordinators,
+    find_verdict_words, render_correction_coverage, scan_text,
+)
+
+
+class DisciplineTableTest(unittest.TestCase):
+    def test_five_disciplines_numbered_1_to_5(self):
+        self.assertEqual(set(DISCIPLINES), {1, 2, 3, 4, 5})
+
+    def test_each_discipline_has_code_operator_split(self):
+        for n, d in DISCIPLINES.items():
+            for key in ("name", "rule", "mechanical", "operator"):
+                self.assertTrue(d[key].strip(), f"D{n} missing {key}")
+
+    def test_discipline_name(self):
+        self.assertEqual(discipline_name(D1), "hold-contradictions")
+        self.assertEqual(discipline_name(D5), "softening-self-check")
+        with self.assertRaises(ValueError):
+            discipline_name(6)
+
+
+class SubordinatorScanTest(unittest.TestCase):
+    def test_finds_but_and_however(self):
+        self.assertIn("but", find_subordinators("X is true, but Y is also true."))
+        self.assertIn("however", find_subordinators("X is true. However, Y."))
+
+    def test_finds_multiword_connectives(self):
+        self.assertIn("which means", find_subordinators("X is true, which means Y."))
+        self.assertIn("in other words", find_subordinators("X. In other words, Y."))
+
+    def test_parallel_sentences_pass(self):
+        self.assertEqual(find_subordinators("X is true. Y is also true."), [])
+
+    def test_held_tension_accepts_parallel(self):
+        t = HeldTension(text="I adored her. I'm furious at her.")
+        self.assertTrue(t.text)
+
+    def test_held_tension_rejects_subordinator(self):
+        with self.assertRaises(ScanError):
+            HeldTension(text="I adored her, but I'm furious at her.")
+        with self.assertRaises(ScanError):
+            HeldTension(text="I adored her. However, I'm furious at her.")
+
+    def test_held_tension_rejects_empty(self):
+        with self.assertRaises(ScanError):
+            HeldTension(text="   ")
+
+
+class VerdictWordScanTest(unittest.TestCase):
+    def test_flags_permanent_label(self):
+        hits = find_verdict_words("He's a liar, that's all there is to it.")
+        self.assertEqual(len(hits), 1)
+        self.assertEqual(hits[0].word, "liar")
+
+    def test_state_description_passes(self):
+        # "he was lying on Tuesday" is a time-indexed state, not a verdict.
+        self.assertEqual(find_verdict_words("He was lying to her on Tuesday."), [])
+
+    def test_adjective_state_passes(self):
+        # Adjectives can legitimately describe a moment — nouns only.
+        self.assertEqual(find_verdict_words("The situation was dangerous."), [])
+
+    def test_person_state_requires_all_fields(self):
+        with self.assertRaises(ScanError):
+            PersonState(when="", person="Dana", state="calm")
+        with self.assertRaises(ScanError):
+            PersonState(when="Tue", person=" ", state="calm")
+        ok = PersonState(when="2026-09-20", person="Dana", state="calm, cooperative")
+        self.assertEqual(ok.person, "Dana")
+
+
+class CorrectionTypingTest(unittest.TestCase):
+    def test_accepts_both_kinds(self):
+        self.assertEqual(Correction(kind="detail", text="3pm, not 2pm.").kind, "detail")
+        self.assertEqual(
+            Correction(kind="core-claim", text="She withdrew the claim.").kind,
+            "core-claim",
+        )
+
+    def test_rejects_bad_kind_and_empty(self):
+        with self.assertRaises(ScanError):
+            Correction(kind="typo", text="whatever")
+        with self.assertRaises(ScanError):
+            Correction(kind="detail", text="  ")
+
+    def test_finds_correction_candidates(self):
+        found = find_correction_candidates(
+            "The meeting was at two. Actually, it was at three. Dana agreed."
+        )
+        self.assertEqual(len(found), 1)
+        self.assertIn("actually", found[0].marker)
+        self.assertTrue(isinstance(found[0], CorrectionCandidate))
+
+    def test_no_candidates_in_clean_text(self):
+        self.assertEqual(
+            find_correction_candidates("The meeting was at two. Dana agreed."), []
+        )
+
+
+class CorrectionCoverageTest(unittest.TestCase):
+    TEXT = ("The meeting was at two. Actually, it was at three. "
+            "Dana agreed to the plan.")
+
+    def test_statuses_typed_candidate_unmarked(self):
+        typed = [Correction(kind="detail", text="Actually, it was at three.")]
+        rows = correction_coverage(self.TEXT, typed)
+        self.assertEqual([r.status for r in rows],
+                         ["unmarked", "typed", "unmarked"])
+        self.assertEqual(rows[1].kind, "detail")
+        self.assertEqual(rows[1].marker, "actually")
+
+    def test_candidate_carries_marker_when_untyped(self):
+        rows = correction_coverage(self.TEXT)
+        cand = rows[1]
+        self.assertEqual(cand.status, "candidate")
+        self.assertEqual(cand.marker, "actually")
+        self.assertEqual(cand.kind, "")
+
+    def test_typed_matches_on_stripped_text(self):
+        typed = [Correction(kind="core-claim",
+                            text="  Actually, it was at three.  ")]
+        rows = correction_coverage(self.TEXT, typed)
+        self.assertEqual(rows[1].status, "typed")
+        self.assertEqual(rows[1].kind, "core-claim")
+
+    def test_typed_matching_is_case_insensitive(self):
+        typed = [Correction(kind="detail",
+                            text="aCtUaLlY, It WaS aT tHrEe.")]
+        rows = correction_coverage(self.TEXT, typed)
+        self.assertEqual(rows[1].status, "typed")
+        self.assertEqual(rows[1].kind, "detail")
+
+    def test_first_typed_correction_wins_on_duplicates(self):
+        typed = [Correction(kind="detail", text="Actually, it was at three."),
+                 Correction(kind="core-claim",
+                            text="ACTUALLY, IT WAS AT THREE.")]
+        rows = correction_coverage(self.TEXT, typed)
+        self.assertEqual(rows[1].status, "typed")
+        self.assertEqual(rows[1].kind, "detail")
+
+    def test_unmatched_typed_correction_is_surfaced_not_dropped(self):
+        typed = [Correction(kind="detail", text="A sentence from nowhere.")]
+        rows = correction_coverage(self.TEXT, typed)
+        self.assertEqual(len(rows), 4)
+        orphan = rows[3]
+        self.assertEqual(orphan.status, "unmatched")
+        self.assertEqual(orphan.kind, "detail")
+        self.assertEqual(orphan.sentence, "A sentence from nowhere.")
+
+    def test_empty_text_has_no_rows(self):
+        self.assertEqual(correction_coverage("   "), [])
+
+    def test_coverage_row_rejects_bad_status_and_kind(self):
+        with self.assertRaises(ScanError):
+            CorrectionCoverage(sentence="x.", status="maybe")
+        with self.assertRaises(ScanError):
+            CorrectionCoverage(sentence="x.", status="typed", kind="typo")
+        with self.assertRaises(ScanError):
+            CorrectionCoverage(sentence="  ", status="unmarked")
+
+    def test_render_publishes_every_sentence_with_status(self):
+        text = (self.TEXT + " To be clear, the venue changed.")
+        typed = [Correction(kind="detail", text="Actually, it was at three."),
+                 Correction(kind="core-claim",
+                            text="A sentence from nowhere.")]
+        rendered = render_correction_coverage(text, typed)
+        self.assertIn("## Correction typing coverage (discipline 3)",
+                      rendered)
+        self.assertIn("- [unmarked] The meeting was at two.", rendered)
+        self.assertIn("- [typed: detail] (marker: 'actually') "
+                      "Actually, it was at three.", rendered)
+        self.assertIn("- [untyped candidate] (marker: 'to be clear,') "
+                      "To be clear, the venue changed.", rendered)
+        self.assertIn("- [unmarked] Dana agreed to the plan.", rendered)
+        self.assertIn("## Typed corrections not found in the text", rendered)
+        self.assertIn("- [unmatched: core-claim] A sentence from nowhere.",
+                      rendered)
+
+    def test_scan_text_carries_coverage_and_filters_typed_candidates(self):
+        typed = [Correction(kind="detail",
+                            text="actually, it was at three.")]
+        report = scan_text(self.TEXT, typed=typed)
+        self.assertEqual([r.status for r in report.correction_coverage],
+                         ["unmarked", "typed", "unmarked"])
+        self.assertEqual(report.correction_coverage[1].kind, "detail")
+        # The typed sentence drops off the needs-typing candidate list.
+        self.assertEqual(report.correction_candidates, [])
+
+    def test_typed_accepts_a_generator(self):
+        def gen():
+            yield Correction(kind="detail", text="Actually, it was at three.")
+            yield Correction(kind="core-claim",
+                             text="A sentence from nowhere.")
+        report = scan_text(self.TEXT, typed=gen())
+        self.assertEqual([r.status for r in report.correction_coverage],
+                         ["unmarked", "typed", "unmarked", "unmatched"])
+        self.assertEqual(report.correction_candidates, [])
+
+    def test_scan_text_without_typed_is_unchanged(self):
+        report = scan_text(self.TEXT)
+        self.assertEqual(len(report.correction_candidates), 1)
+        self.assertEqual(report.correction_candidates[0].marker, "actually")
+        self.assertEqual([r.status for r in report.correction_coverage],
+                         ["unmarked", "candidate", "unmarked"])
+
+
+class MotiveScanTest(unittest.TestCase):
+    def test_flags_supplied_motive(self):
+        flags = detect_supplied_motive("He tackled you because he panicked.")
+        self.assertEqual(len(flags), 1)
+        self.assertEqual(flags[0].severity, "flag")
+        self.assertTrue(isinstance(flags[0], MotiveFlag))
+
+    def test_attributed_motive_is_clean(self):
+        # The teller assigned the why — discipline 4 satisfied.
+        self.assertEqual(
+            detect_supplied_motive("He said he panicked when it happened."), []
+        )
+
+    def test_bare_quote_is_not_attribution(self):
+        # Scare quotes must not pass as sourcing (PARAM-POSTMO-014):
+        # the quote alone no longer suppresses the motive flag.
+        flags = detect_supplied_motive(
+            "He panicked and \"ran\" when it happened.")
+        self.assertEqual(len(flags), 1)
+        self.assertEqual(flags[0].severity, "flag")
+
+    def test_quote_adjacent_speech_verb_is_attribution(self):
+        self.assertEqual(
+            detect_supplied_motive("\"He panicked and ran,\" she admitted."),
+            [])
+        self.assertEqual(
+            detect_supplied_motive("She admitted, \"He panicked and ran.\""),
+            [])
+        self.assertEqual(
+            detect_supplied_motive(
+                "\"He panicked and ran,\" the witness admitted."), []
+        )
+        self.assertEqual(
+            detect_supplied_motive("The report quotes him: "
+                                   "\"He panicked and ran.\""),
+            [])
+
+    def test_verb_in_unrelated_clause_is_not_attribution(self):
+        # "admitted" belongs to another clause — the scare quote stays
+        # unattributed. ("said" would be a marker regardless.)
+        flags = detect_supplied_motive(
+            "He panicked and \"ran\" when the witness admitted "
+            "he was afraid.")
+        self.assertEqual(len(flags), 1)
+        self.assertEqual(flags[0].severity, "flag")
+
+    def test_quote_with_marker_still_clean(self):
+        self.assertEqual(
+            detect_supplied_motive("\"He panicked and ran,\" she said."), []
+        )
+
+    def test_marked_guess_is_allowed_but_kept(self):
+        flags = detect_supplied_motive("If I had to guess, he panicked.")
+        self.assertEqual(len(flags), 1)
+        self.assertEqual(flags[0].severity, "guess")
+
+    def test_flags_driven_by_and_out_of(self):
+        self.assertTrue(detect_supplied_motive("It was driven by fear."))
+        self.assertTrue(detect_supplied_motive("She did it out of spite."))
+
+    def test_observed_sequence_passes(self):
+        self.assertEqual(
+            detect_supplied_motive("He tackled you. You fell. He walked away."), []
+        )
+
+    def test_motive_flag_rejects_bad_severity(self):
+        with self.assertRaises(ScanError):
+            MotiveFlag(sentence="x", pattern="y", severity="verdict")
+
+
+class SofteningScanTest(unittest.TestCase):
+    def test_downgrade_betrayal_to_mistake(self):
+        result = detect_softening(
+            "It was a betrayal of my trust.", "It was a mistake."
+        )
+        self.assertIsInstance(result, SofteningResult)
+        kinds = [f.kind for f in result.flags]
+        self.assertIn("downgrade", kinds)
+        down = next(f for f in result.flags if f.kind == "downgrade")
+        self.assertEqual(down.original_term, "betrayal")
+        self.assertEqual(down.replacement, "mistake")
+
+    def test_dropped_strong_term(self):
+        result = detect_softening("He lied to me.", "It was complicated.")
+        self.assertTrue(any(
+            f.kind == "dropped" and f.original_term == "lied"
+            for f in result.flags
+        ))
+
+    def test_strong_term_kept_is_clean(self):
+        result = detect_softening("He lied to me.", "He lied, and it hurt.")
+        self.assertEqual(result.flags, [])
+
+    def test_tidy_restatement_phrase(self):
+        result = detect_softening(
+            "I adored her. I'm furious at her.",
+            "So what you're saying is you have mixed feelings.",
+        )
+        self.assertTrue(any(f.kind == "tidy-restatement"
+                            for f in result.flags))
+
+    def test_ambivalence_resolved(self):
+        result = detect_softening(
+            "I adored her. I'm furious at her.",
+            "The real feeling underneath is anger.",
+        )
+        self.assertTrue(any(f.kind == "ambivalence-resolved"
+                            for f in result.flags))
+
+
+class SofteningResultTest(unittest.TestCase):
+    def test_result_carries_coverage(self):
+        result = detect_softening("He lied to me.", "He lied, and it hurt.")
+        self.assertEqual(result.pairs_consulted, len(DOWNGRADE_PAIRS))
+        self.assertEqual(result.scope_note,
+                         "closed 1:1 table; off-table synonyms not evaluated")
+        self.assertEqual(result.grammar_required, "copula")
+
+    def test_downgrade_table_stays_closed(self):
+        # PARAM-POSTMO-016: the table itself is wont_change — pin the
+        # size so an accidental expansion trips loudly.
+        self.assertEqual(len(DOWNGRADE_PAIRS), 23)
+        self.assertIn(("betrayal", "mistake"), DOWNGRADE_PAIRS)
+
+    def test_matching_semantics_untouched_exact_flag_sequence(self):
+        # Regression parity: the exact flag sequence for a multi-hit
+        # input — kinds, terms, and order — is unchanged by the return
+        # contract (pairs loop order, then tidy, then ambivalence).
+        result = detect_softening(
+            "It was a betrayal. He lied to me.",
+            "So what you're saying is it was a mistake.",
+        )
+        self.assertEqual(
+            [(f.kind, f.original_term, f.replacement)
+             for f in result.flags],
+            [("downgrade", "betrayal", "mistake"),
+             ("dropped", "lied", ""),
+             ("tidy-restatement", "", "")],
+        )
+
+    def test_softening_checked_property(self):
+        self.assertTrue(scan_text(
+            "He arrived at three.", restatement="He arrived.").softening_checked)
+        self.assertFalse(
+            scan_text("He arrived at three.").softening_checked)
+
+    def test_report_constructible_with_result_directly(self):
+        from postmo.scans import SofteningFlag
+        result = SofteningResult(flags=[SofteningFlag(
+            kind="dropped", detail="'lied' vanished.")])
+        report = ScanReport(softening=result)
+        self.assertEqual(report.softening_state(), "flagged")
+        self.assertFalse(report.clean())
+        self.assertEqual(len(report.softening_flags), 1)
+
+    def test_empty_flags_distinguishable_from_unchecked(self):
+        # D5 ran, no flags: the result exists and is empty — "no tripwire
+        # fired", not "text is clean".
+        checked = scan_text(
+            "He arrived at three.",
+            restatement="He arrived at three.",
+        )
+        self.assertIsNotNone(checked.softening)
+        self.assertEqual(checked.softening.flags, [])
+        self.assertEqual(checked.softening_state(), "clean")
+        self.assertTrue(checked.clean())
+        # D5 never ran: no result at all.
+        unchecked = scan_text("He arrived at three.")
+        self.assertIsNone(unchecked.softening)
+        self.assertEqual(unchecked.softening_state(), "not-checked")
+        self.assertFalse(unchecked.clean())
+
+    def test_report_softening_flags_property(self):
+        unchecked = scan_text("He arrived at three.")
+        self.assertEqual(unchecked.softening_flags, [])
+        flagged = scan_text("He lied to me.",
+                              restatement="It was complicated.")
+        self.assertEqual(flagged.softening_flags, flagged.softening.flags)
+        self.assertTrue(flagged.softening_flags)
+
+
+class BatchScanTest(unittest.TestCase):
+    def test_scan_text_fires_everything(self):
+        report = scan_text(
+            "He's a liar. Actually, he tackled you because he panicked, but I adored him.",
+            restatement="So what you're saying is he made a mistake.",
+        )
+        self.assertTrue(report.subordinators)
+        self.assertTrue(report.verdict_words)
+        self.assertTrue(report.correction_candidates)
+        self.assertTrue(report.motive_flags)
+        self.assertTrue(report.softening_flags)
+        self.assertFalse(report.clean())
+
+    def test_scan_text_clean_with_restatement(self):
+        report = scan_text(
+            "He arrived at three. She left at four. Both of those happened.",
+            restatement="He arrived at three. She left at four.",
+        )
+        self.assertTrue(report.softening_checked)
+        self.assertEqual(report.softening_state(), "clean")
+        self.assertTrue(report.clean())
+
+    def test_scan_text_not_clean_when_d5_unchecked(self):
+        # PARAM-POSTMO-015: no restatement → D5 never ran → the report
+        # must not claim clean, and the state says so explicitly.
+        report = scan_text(
+            "He arrived at three. She left at four. Both of those happened."
+        )
+        self.assertFalse(report.softening_checked)
+        self.assertEqual(report.softening_state(), "not-checked")
+        self.assertFalse(report.clean())
+
+    def test_softening_state_flagged(self):
+        report = scan_text(
+            "It was a betrayal of my trust.",
+            restatement="It was a mistake.",
+        )
+        self.assertTrue(report.softening_checked)
+        self.assertEqual(report.softening_state(), "flagged")
+        self.assertFalse(report.clean())
+
+
+class LintExampleTest(unittest.TestCase):
+    def _run_lint(self, draft_text, extra_args=()):
+        with tempfile.TemporaryDirectory() as tmp:
+            draft = os.path.join(tmp, "draft.txt")
+            with open(draft, "w", encoding="utf-8") as f:
+                f.write(draft_text)
+            env = dict(os.environ,
+                       PYTHONPATH=os.path.join(AUDIT_DIR, "src"))
+            return subprocess.run(
+                [sys.executable, "examples/lint_audit.py",
+                 "--text", draft, *extra_args],
+                capture_output=True, text=True, cwd=AUDIT_DIR, env=env,
+            )
+
+    def test_cli_prints_unchecked_d5_notice(self):
+        proc = self._run_lint("He arrived at three. She left at four.\n")
+        self.assertEqual(proc.returncode, 0)
+        self.assertIn("softening not checked", proc.stdout)
+        self.assertIn("Not checked' is not 'no softening found'", proc.stdout)
+
+    def test_cli_no_notice_when_restatement_given(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            rest = os.path.join(tmp, "rest.txt")
+            with open(rest, "w", encoding="utf-8") as f:
+                f.write("He arrived at three.\n")
+            proc = self._run_lint("He arrived at three. She left at four.\n",
+                                  extra_args=("--restatement", rest))
+        self.assertEqual(proc.returncode, 0)
+        self.assertNotIn("softening not checked", proc.stdout)
+
+
+if __name__ == "__main__":
+    unittest.main()

postmo-1.0.0/tests/test_scans.py

@@ -1,198 +0,0 @@
-"""Tests for the mechanical linter checks (scans.py) and the discipline table."""
-
-import unittest
-
-from postmo.disciplines import D1, D2, D3, D4, D5, DISCIPLINES, discipline_name
-from postmo.scans import (
-    Correction, CorrectionCandidate, HeldTension, MotiveFlag, PersonState,
-    ScanError, detect_softening, detect_supplied_motive,
-    find_correction_candidates, find_subordinators, find_verdict_words,
-    scan_text,
-)
-
-
-class DisciplineTableTest(unittest.TestCase):
-    def test_five_disciplines_numbered_1_to_5(self):
-        self.assertEqual(set(DISCIPLINES), {1, 2, 3, 4, 5})
-
-    def test_each_discipline_has_code_operator_split(self):
-        for n, d in DISCIPLINES.items():
-            for key in ("name", "rule", "mechanical", "operator"):
-                self.assertTrue(d[key].strip(), f"D{n} missing {key}")
-
-    def test_discipline_name(self):
-        self.assertEqual(discipline_name(D1), "hold-contradictions")
-        self.assertEqual(discipline_name(D5), "softening-self-check")
-        with self.assertRaises(ValueError):
-            discipline_name(6)
-
-
-class SubordinatorScanTest(unittest.TestCase):
-    def test_finds_but_and_however(self):
-        self.assertIn("but", find_subordinators("X is true, but Y is also true."))
-        self.assertIn("however", find_subordinators("X is true. However, Y."))
-
-    def test_finds_multiword_connectives(self):
-        self.assertIn("which means", find_subordinators("X is true, which means Y."))
-        self.assertIn("in other words", find_subordinators("X. In other words, Y."))
-
-    def test_parallel_sentences_pass(self):
-        self.assertEqual(find_subordinators("X is true. Y is also true."), [])
-
-    def test_held_tension_accepts_parallel(self):
-        t = HeldTension(text="I adored her. I'm furious at her.")
-        self.assertTrue(t.text)
-
-    def test_held_tension_rejects_subordinator(self):
-        with self.assertRaises(ScanError):
-            HeldTension(text="I adored her, but I'm furious at her.")
-        with self.assertRaises(ScanError):
-            HeldTension(text="I adored her. However, I'm furious at her.")
-
-    def test_held_tension_rejects_empty(self):
-        with self.assertRaises(ScanError):
-            HeldTension(text="   ")
-
-
-class VerdictWordScanTest(unittest.TestCase):
-    def test_flags_permanent_label(self):
-        hits = find_verdict_words("He's a liar, that's all there is to it.")
-        self.assertEqual(len(hits), 1)
-        self.assertEqual(hits[0].word, "liar")
-
-    def test_state_description_passes(self):
-        # "he was lying on Tuesday" is a time-indexed state, not a verdict.
-        self.assertEqual(find_verdict_words("He was lying to her on Tuesday."), [])
-
-    def test_adjective_state_passes(self):
-        # Adjectives can legitimately describe a moment — nouns only.
-        self.assertEqual(find_verdict_words("The situation was dangerous."), [])
-
-    def test_person_state_requires_all_fields(self):
-        with self.assertRaises(ScanError):
-            PersonState(when="", person="Dana", state="calm")
-        with self.assertRaises(ScanError):
-            PersonState(when="Tue", person=" ", state="calm")
-        ok = PersonState(when="2026-09-20", person="Dana", state="calm, cooperative")
-        self.assertEqual(ok.person, "Dana")
-
-
-class CorrectionTypingTest(unittest.TestCase):
-    def test_accepts_both_kinds(self):
-        self.assertEqual(Correction(kind="detail", text="3pm, not 2pm.").kind, "detail")
-        self.assertEqual(
-            Correction(kind="core-claim", text="She withdrew the claim.").kind,
-            "core-claim",
-        )
-
-    def test_rejects_bad_kind_and_empty(self):
-        with self.assertRaises(ScanError):
-            Correction(kind="typo", text="whatever")
-        with self.assertRaises(ScanError):
-            Correction(kind="detail", text="  ")
-
-    def test_finds_correction_candidates(self):
-        found = find_correction_candidates(
-            "The meeting was at two. Actually, it was at three. Dana agreed."
-        )
-        self.assertEqual(len(found), 1)
-        self.assertIn("actually", found[0].marker)
-        self.assertTrue(isinstance(found[0], CorrectionCandidate))
-
-    def test_no_candidates_in_clean_text(self):
-        self.assertEqual(
-            find_correction_candidates("The meeting was at two. Dana agreed."), []
-        )
-
-
-class MotiveScanTest(unittest.TestCase):
-    def test_flags_supplied_motive(self):
-        flags = detect_supplied_motive("He tackled you because he panicked.")
-        self.assertEqual(len(flags), 1)
-        self.assertEqual(flags[0].severity, "flag")
-        self.assertTrue(isinstance(flags[0], MotiveFlag))
-
-    def test_attributed_motive_is_clean(self):
-        # The teller assigned the why — discipline 4 satisfied.
-        self.assertEqual(
-            detect_supplied_motive("He said he panicked when it happened."), []
-        )
-
-    def test_marked_guess_is_allowed_but_kept(self):
-        flags = detect_supplied_motive("If I had to guess, he panicked.")
-        self.assertEqual(len(flags), 1)
-        self.assertEqual(flags[0].severity, "guess")
-
-    def test_flags_driven_by_and_out_of(self):
-        self.assertTrue(detect_supplied_motive("It was driven by fear."))
-        self.assertTrue(detect_supplied_motive("She did it out of spite."))
-
-    def test_observed_sequence_passes(self):
-        self.assertEqual(
-            detect_supplied_motive("He tackled you. You fell. He walked away."), []
-        )
-
-    def test_motive_flag_rejects_bad_severity(self):
-        with self.assertRaises(ScanError):
-            MotiveFlag(sentence="x", pattern="y", severity="verdict")
-
-
-class SofteningScanTest(unittest.TestCase):
-    def test_downgrade_betrayal_to_mistake(self):
-        flags = detect_softening(
-            "It was a betrayal of my trust.", "It was a mistake."
-        )
-        kinds = [f.kind for f in flags]
-        self.assertIn("downgrade", kinds)
-        down = next(f for f in flags if f.kind == "downgrade")
-        self.assertEqual(down.original_term, "betrayal")
-        self.assertEqual(down.replacement, "mistake")
-
-    def test_dropped_strong_term(self):
-        flags = detect_softening("He lied to me.", "It was complicated.")
-        self.assertTrue(any(
-            f.kind == "dropped" and f.original_term == "lied" for f in flags
-        ))
-
-    def test_strong_term_kept_is_clean(self):
-        self.assertEqual(
-            detect_softening("He lied to me.", "He lied, and it hurt."), []
-        )
-
-    def test_tidy_restatement_phrase(self):
-        flags = detect_softening(
-            "I adored her. I'm furious at her.",
-            "So what you're saying is you have mixed feelings.",
-        )
-        self.assertTrue(any(f.kind == "tidy-restatement" for f in flags))
-
-    def test_ambivalence_resolved(self):
-        flags = detect_softening(
-            "I adored her. I'm furious at her.",
-            "The real feeling underneath is anger.",
-        )
-        self.assertTrue(any(f.kind == "ambivalence-resolved" for f in flags))
-
-
-class BatchScanTest(unittest.TestCase):
-    def test_scan_text_fires_everything(self):
-        report = scan_text(
-            "He's a liar. Actually, he tackled you because he panicked, but I adored him.",
-            restatement="So what you're saying is he made a mistake.",
-        )
-        self.assertTrue(report.subordinators)
-        self.assertTrue(report.verdict_words)
-        self.assertTrue(report.correction_candidates)
-        self.assertTrue(report.motive_flags)
-        self.assertTrue(report.softening_flags)
-        self.assertFalse(report.clean())
-
-    def test_scan_text_clean(self):
-        report = scan_text(
-            "He arrived at three. She left at four. Both of those happened."
-        )
-        self.assertTrue(report.clean())
-
-
-if __name__ == "__main__":
-    unittest.main()