fairit 1.0.0__py3-none-any.whl

fairit/__init__.py

@@ -0,0 +1,64 @@
+"""fairit — pre-interrogation ground mapping and evasion testing.
+
+Map the ground (held tensions, time-indexed states, typed corrections),
+test evasion hypotheses (never presume them), and hand off 2-3 seed
+frames to whatever comes next. The package never collides, adjudicates,
+refines, or extracts surprise — it audits and hands off.
+"""
+
+from .brief import AuditBrief, BriefError, check_stand_down, parse
+from .dialects import DIALECTS, SHIELD_MARKERS, detect_markers
+from .evidence import (
+    TAXONOMY,
+    EvidenceError,
+    EvidenceItem,
+    check_matches_engine,
+    forge_mapping_table,
+    normalize_tag,
+    tag_list,
+)
+from .ground import (
+    Correction,
+    GroundError,
+    GroundMap,
+    HeldTension,
+    PersonState,
+    find_subordinators,
+)
+from .hypotheses import (
+    H_BOTH,
+    H_GENUINE,
+    H_OBFUSCATION,
+    INSUFFICIENT_EVIDENCE,
+    SUPPORT_STATUSES,
+    VERDICTS,
+    CategoryPresumptionError,
+    DiscriminatingEvidence,
+    HypothesisError,
+    HypothesisRecord,
+    Mechanism,
+)
+from .overlay import (
+    JargonFlag,
+    ObfuscatedObject,
+    ProbeError,
+    evidence_tag_for,
+    run_jargon_test,
+    scan_and_test,
+)
+
+__all__ = [
+    "AuditBrief", "BriefError", "check_stand_down", "parse",
+    "DIALECTS", "SHIELD_MARKERS", "detect_markers",
+    "TAXONOMY", "EvidenceError", "EvidenceItem", "check_matches_engine",
+    "forge_mapping_table", "normalize_tag", "tag_list",
+    "Correction", "GroundError", "GroundMap", "HeldTension", "PersonState",
+    "find_subordinators",
+    "H_BOTH", "H_GENUINE", "H_OBFUSCATION", "INSUFFICIENT_EVIDENCE",
+    "SUPPORT_STATUSES", "VERDICTS", "CategoryPresumptionError",
+    "DiscriminatingEvidence", "HypothesisError", "HypothesisRecord", "Mechanism",
+    "JargonFlag", "ObfuscatedObject", "ProbeError", "evidence_tag_for",
+    "run_jargon_test", "scan_and_test",
+]
+
+__version__ = "1.0.0"

fairit/brief.py

@@ -0,0 +1,131 @@
+"""The audit brief — the overlay's output artifact.
+
+The brief records what was audited, which evasion hypotheses were tested
+and their support status, and what seeds were handed off. It is a brief,
+not an interrogation result: the interrogation engine's state artifact
+stays canonical.
+
+Stand-down rule, enforced in code: the brief must NEVER contain
+collision, adjudication, refinement, or surprise sections. Those belong
+to the interrogation engine. If the engine isn't running, the brief is
+reported and the work stops.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from datetime import date
+
+from .ground import GroundMap
+from .hypotheses import HypothesisRecord, H_OBFUSCATION
+
+# Headings the overlay must never emit. A brief that collides or
+# adjudicates has left its lane — the schema rejects it.
+FORBIDDEN_SECTIONS = (
+    "collision", "collide", "adjudicat", "refinement", "refine",
+    "surprise",
+)
+
+
+class BriefError(ValueError):
+    """Raised when a brief breaks the schema or the stand-down rule."""
+
+
+def check_stand_down(rendered: str) -> None:
+    """Reject rendered text that contains engine-owned sections."""
+    headings = re.findall(r"^#{1,3}\s*(.+)$", rendered, re.MULTILINE)
+    for heading in headings:
+        lowered = heading.lower()
+        for forbidden in FORBIDDEN_SECTIONS:
+            if forbidden in lowered:
+                raise BriefError(
+                    f"Stand-down violation: the brief must not contain a "
+                    f"'{heading.strip()}' section. Collision, adjudication, "
+                    "refinement, and surprise belong to the interrogation "
+                    "engine — this overlay audits and hands off, nothing more."
+                )
+
+
+@dataclass
+class AuditBrief:
+    """Audited ground + tested hypotheses + handoff seeds."""
+
+    case_name: str
+    ground: GroundMap = field(default_factory=GroundMap)
+    records: list[HypothesisRecord] = field(default_factory=list)
+    seeds: list[str] = field(default_factory=list)
+    lifecycle: str = "FINAL"
+    brief_date: str = field(default_factory=lambda: date.today().isoformat())
+
+    def __post_init__(self) -> None:
+        if not self.case_name.strip():
+            raise BriefError("Brief needs a case name.")
+        if self.lifecycle not in ("INITIAL", "ITERATIVE", "FINAL"):
+            raise BriefError(f"Bad lifecycle: {self.lifecycle!r}.")
+        if not (2 <= len(self.seeds) <= 3):
+            raise BriefError(
+                f"Handoff must produce 2-3 seed frames, got {len(self.seeds)}."
+            )
+        for seed in self.seeds:
+            if not seed.strip():
+                raise BriefError("Seed frames must not be empty.")
+
+    def obfuscation_supported(self) -> bool:
+        """True only when some record's H-obfuscation is supported."""
+        return any(r.supports_obfuscation() for r in self.records)
+
+    def render(self) -> str:
+        lines = [
+            "---",
+            "artifact: audit-brief",
+            f"date: {self.brief_date}",
+            "protocol: fairit/1.0",
+            f"lifecycle: {self.lifecycle}",
+            "---",
+            "",
+            f"# Audit brief: {self.case_name}",
+            "",
+            self.ground.render(),
+            "",
+            "## Tested hypotheses",
+        ]
+        for record in self.records:
+            lines.append("")
+            lines.append(record.summary())
+        lines.extend(["", "## Handoff seeds"])
+        for i, seed in enumerate(self.seeds, 1):
+            lines.append(f"{i}. {seed}")
+        rendered = "\n".join(lines)
+        check_stand_down(rendered)
+        return rendered
+
+
+def parse(rendered: str) -> AuditBrief:
+    """Parse a rendered brief back into an AuditBrief.
+
+    Round-trip fidelity: case name, lifecycle, date, and seeds survive.
+    Ground and hypothesis records parse back as their raw text — the
+    structured re-validation is the caller's job on re-entry.
+    """
+    check_stand_down(rendered)
+    front = dict(
+        line.split(":", 1)
+        for line in rendered.splitlines()
+        if re.match(r"^(artifact|date|protocol|lifecycle):", line)
+    )
+    if front.get("artifact", "").strip() != "audit-brief":
+        raise BriefError("Not an audit-brief artifact.")
+    match = re.search(r"^# Audit brief: (.+)$", rendered, re.MULTILINE)
+    if not match:
+        raise BriefError("Brief is missing its case-name heading.")
+    seed_lines: list[str] = []
+    if "## Handoff seeds" in rendered:
+        tail = rendered.split("## Handoff seeds", 1)[1]
+        seed_lines = [s.strip() for s in re.findall(r"^\d+\. (.+)$", tail, re.MULTILINE)]
+    return AuditBrief(
+        case_name=match.group(1).strip(),
+        lifecycle=front.get("lifecycle", "FINAL").strip() or "FINAL",
+        brief_date=front.get("date", "").strip() or date.today().isoformat(),
+        seeds=seed_lines,
+    )

fairit/dialects.py

@@ -0,0 +1,54 @@
+"""Shield-vocabulary marker lists, by dialect.
+
+These lists detect *candidate* instances of jargon that MAY function as
+evasion. Detection is the start of the hypothesis protocol, never its
+conclusion: a marker hit feeds H-obfuscation / H-genuine / H-both
+testing in `hypotheses.py`. No marker, list, or dialect ever produces a
+verdict by itself.
+
+The original skill only knew therapy-speak. The same structure covers
+corporate-speak and bureaucratic passive voice — the mechanism doesn't
+care which dialect the shield is written in.
+"""
+
+from __future__ import annotations
+
+# (dialect, phrases). Phrases are matched case-insensitively as
+# substrings — they are tripwires, not judgments.
+SHIELD_MARKERS: dict[str, tuple[str, ...]] = {
+    "therapy": (
+        "holding space", "doing the work", "inner child", "boundaries",
+        "triggered", "processing", "my truth", "self-care", "nervous system",
+        "regulation", "co-regulation", "shadow work", "attachment style",
+        "parts of me", "sitting with", "unpacking",
+    ),
+    "corporate": (
+        "circle back", "synergy", "leverage", "bandwidth", "deep dive",
+        "move the needle", "take this offline", "low-hanging fruit",
+        "best practices", "thought leadership", "rightsizing",
+        "synergize", "actionable", "paradigm",
+    ),
+    "bureaucratic": (
+        "mistakes were made", "regrettable", "inappropriate", "it was decided",
+        "processes were followed", "at this time", "going forward",
+        "lessons learned", "unfortunate", "miscommunication",
+        "administrative error", "procedural",
+    ),
+}
+
+DIALECTS = tuple(SHIELD_MARKERS)
+
+
+def detect_markers(text: str) -> list[tuple[str, str]]:
+    """Find candidate shield-vocabulary instances.
+
+    Returns a list of (dialect, phrase) hits. A hit is a candidate for
+    hypothesis testing — it says "examine this," nothing more.
+    """
+    lowered = text.lower()
+    hits: list[tuple[str, str]] = []
+    for dialect, phrases in SHIELD_MARKERS.items():
+        for phrase in phrases:
+            if phrase in lowered:
+                hits.append((dialect, phrase))
+    return hits

fairit/evidence.py

@@ -0,0 +1,177 @@
+"""The authoritative evidence taxonomy for this package.
+
+Lineage: the interrogation engine (`adversarial_ifs`, in the sibling
+`ifs/` conversion) defines an 11-tag taxonomy — 10 core tiers plus one
+overlay-only tag (OBFUSCATION). field-forge shipped its own 8-tier list.
+This module is the ONE authoritative mapping: field-forge's 8 tiers map
+1:1 onto the engine's taxonomy, and the 3 tiers the forge never named
+(HYPOTHESIS, REQUIREMENT, DEPENDENCY) are documented as recognized —
+not as a second taxonomy.
+
+The authoritative set is vendored here (with the lineage note above) so
+this package stays standalone, stdlib-only, with no path dependency on
+its sibling. `check_matches_engine()` guards against silent forks: if
+`adversarial_ifs` is importable, it asserts the two taxonomies are
+identical; if it isn't, the check skips and the vendored copy stands.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# --- The authoritative taxonomy (11 tags) -----------------------------------
+
+FACT = "FACT"
+OBSERVATION = "OBSERVATION"
+CLAIM = "CLAIM"
+INFERENCE = "INFERENCE"
+ASSUMPTION = "ASSUMPTION"
+HYPOTHESIS = "HYPOTHESIS"
+REQUIREMENT = "REQUIREMENT"
+CONSTRAINT = "CONSTRAINT"
+DEPENDENCY = "DEPENDENCY"
+UNKNOWN = "UNKNOWN"
+# Overlay-only: set only when the evasion probe ran AND the evasion
+# hypothesis is supported by discriminating evidence.
+OBFUSCATION = "OBFUSCATION"
+
+TAXONOMY: dict[str, str] = {
+    FACT: "Directly established, unassailable ground truth.",
+    OBSERVATION: "Reported or logged, but not independently verified.",
+    CLAIM: "An explicit assertion made by an actor or source.",
+    INFERENCE: "A conclusion logically drawn from facts or verified observations.",
+    ASSUMPTION: "Presumed true without adequate supporting evidence.",
+    HYPOTHESIS: "A proposed explanatory model that still needs stress-testing.",
+    REQUIREMENT: "A condition that must be true for a model to hold.",
+    CONSTRAINT: "A boundary condition limiting viable outcomes.",
+    DEPENDENCY: "An element relying directly on the state of another.",
+    UNKNOWN: "A critical variable that cannot presently be determined.",
+    OBFUSCATION: (
+        # Definition text is identical to adversarial_ifs.evidence on
+        # purpose — check_matches_engine() enforces byte-identical
+        # definitions so the two taxonomies can never silently fork.
+        "Evasive maneuver or jargon shield masking responsibility. "
+        "Tag ONLY when the evasion-probe overlay is active and the evasion "
+        "hypothesis is supported by discriminating evidence."
+    ),
+}
+
+CORE_TAGS = frozenset(
+    {FACT, OBSERVATION, CLAIM, INFERENCE, ASSUMPTION, HYPOTHESIS,
+     REQUIREMENT, CONSTRAINT, DEPENDENCY, UNKNOWN}
+)
+
+
+class EvidenceError(ValueError):
+    """Raised when an evidence item breaks the taxonomy rules."""
+
+
+@dataclass(frozen=True)
+class EvidenceItem:
+    """One tagged input to the audit."""
+
+    text: str
+    tag: str
+
+    def __post_init__(self) -> None:
+        tag = self.tag.strip().upper()
+        if tag not in TAXONOMY:
+            raise EvidenceError(
+                f"Unknown evidence tag {self.tag!r}. "
+                f"Valid tags: {', '.join(sorted(TAXONOMY))}."
+            )
+        if not self.text.strip():
+            raise EvidenceError("Evidence item text must not be empty.")
+
+
+def normalize_tag(tag: str, *, probe_ran: bool = False) -> str:
+    """Validate and normalize a tag. OBFUSCATION needs the probe.
+
+    The probe-run requirement is the taxonomy-level twin of the
+    hypothesis gate in `hypotheses.py`: the tag may exist on paper,
+    but it may only be *used* when H-obfuscation was actually supported.
+    """
+    normalized = tag.strip().upper()
+    if normalized not in TAXONOMY:
+        raise EvidenceError(f"Unknown evidence tag {tag!r}.")
+    if normalized == OBFUSCATION and not probe_ran:
+        raise EvidenceError(
+            "OBFUSCATION is overlay-only: it may be tagged only when the "
+            "evasion probe ran and H-obfuscation is supported by "
+            "discriminating evidence. Use CLAIM with a hypothesis marker "
+            "for suspected-but-untested evasion."
+        )
+    return normalized
+
+
+# --- The field-forge reconciliation ------------------------------------------
+#
+# field-forge's 8-tier list (from its SKILL.md), mapped onto the
+# authoritative taxonomy. Every forge tier maps 1:1 — no renames, no
+# splits. The 3 tiers the forge never named are listed as RECOGNIZED:
+# valid tags the forge simply didn't use, now available everywhere.
+#
+#   forge FACT        -> FACT
+#   forge OBSERVATION -> OBSERVATION
+#   forge CLAIM       -> CLAIM
+#   forge OBFUSCATION -> OBFUSCATION (same overlay-only rule)
+#   forge INFERENCE   -> INFERENCE
+#   forge ASSUMPTION  -> ASSUMPTION
+#   forge CONSTRAINT  -> CONSTRAINT
+#   forge UNKNOWN     -> UNKNOWN
+#   (not named by forge) HYPOTHESIS, REQUIREMENT, DEPENDENCY -> RECOGNIZED
+
+FORGE_TIERS = frozenset(
+    {"FACT", "OBSERVATION", "CLAIM", "OBFUSCATION", "INFERENCE",
+     "ASSUMPTION", "CONSTRAINT", "UNKNOWN"}
+)
+
+FORGE_MISSING = frozenset({"HYPOTHESIS", "REQUIREMENT", "DEPENDENCY"})
+
+
+def forge_mapping_table() -> str:
+    """The reconciliation, as a human-readable table."""
+    lines = [
+        "| field-forge 8-tier | authoritative tag | status |",
+        "|--------------------|-------------------|--------|",
+    ]
+    for tier in sorted(FORGE_TIERS):
+        lines.append(f"| {tier} | {tier} | 1:1 map |")
+    for tier in sorted(FORGE_MISSING):
+        lines.append(f"| (not named) | {tier} | recognized |")
+    return "\n".join(lines)
+
+
+def check_matches_engine() -> str:
+    """Assert this taxonomy matches adversarial_ifs' — guard against forks.
+
+    Returns "matches" on success. Skips (returns "skipped: adversarial_ifs
+    not importable") when the sibling package isn't on the path — the
+    vendored copy above remains authoritative either way.
+    """
+    try:
+        import adversarial_ifs.evidence as engine_evidence
+    except ImportError:
+        return "skipped: adversarial_ifs not importable"
+    ours = set(TAXONOMY)
+    theirs = set(engine_evidence.TAXONOMY)
+    if ours != theirs:
+        raise EvidenceError(
+            "Taxonomy fork detected: fairit and adversarial_ifs "
+            f"disagree. Only here: {sorted(ours - theirs)}; "
+            f"only in engine: {sorted(theirs - ours)}. "
+            "Reconcile before shipping."
+        )
+    for tag in ours:
+        if TAXONOMY[tag] != engine_evidence.TAXONOMY[tag]:
+            raise EvidenceError(
+                f"Taxonomy fork detected: definition of {tag} differs "
+                "between fairit and adversarial_ifs. Reconcile "
+                "before shipping."
+            )
+    return "matches"
+
+
+def tag_list() -> list[str]:
+    """All valid tags, in canonical order."""
+    return list(TAXONOMY)

fairit/ground.py

@@ -0,0 +1,123 @@
+"""Ground mapping — the pre-interrogation audit of situational state.
+
+Objective: establish exactly what is the case WITHOUT forcing narrative
+resolution. Three outputs:
+
+- Held tensions: opposing facts stated as parallel, non-subordinating
+  sentences ("X is true. Y is also true."). Never "X, but Y" — the
+  subordinating conjunction quietly privileges one side, which is a
+  resolution smuggled in as grammar.
+- Time-indexed person-state sequence: people change across time; map the
+  states, never flatten a person to one characterization.
+- Corrections typed as detail vs core-claim: fixing a date is a detail;
+  changing what was claimed to have happened is a core-claim change —
+  and the latter is the signal.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+# Subordinating conjunctions that privilege one side of a tension.
+# "X is true. Y is also true." stays. "X is true, but Y" is rejected —
+# the "but" resolves the contradiction by demoting X.
+SUBORDINATORS = (
+    "but", "however", "although", "though", "yet", "whereas",
+    "nevertheless", "nonetheless", "which means", "in other words",
+    "so really", "that is to say",
+)
+
+_SUB_RE = re.compile(
+    r"\b(" + "|".join(re.escape(s) for s in SUBORDINATORS) + r")\b",
+    re.IGNORECASE,
+)
+
+
+class GroundError(ValueError):
+    """Raised when mapped ground breaks the audit rules."""
+
+
+def find_subordinators(text: str) -> list[str]:
+    """Return the subordinating conjunctions found in the text."""
+    return sorted({m.group(0).lower() for m in _SUB_RE.finditer(text)})
+
+
+@dataclass(frozen=True)
+class HeldTension:
+    """One pair of opposing facts, held live as parallel sentences."""
+
+    text: str
+
+    def __post_init__(self) -> None:
+        if not self.text.strip():
+            raise GroundError("Held tension must not be empty.")
+        bad = find_subordinators(self.text)
+        if bad:
+            raise GroundError(
+                f"Held tension uses subordinating language {bad}: "
+                f"{self.text!r}. Restate as parallel non-subordinating "
+                "sentences — 'X is true. Y is also true.'"
+            )
+
+
+@dataclass(frozen=True)
+class PersonState:
+    """One person, one moment, one observed state. Time-indexed."""
+
+    when: str
+    person: str
+    state: str
+
+    def __post_init__(self) -> None:
+        for label, value in (("when", self.when), ("person", self.person),
+                             ("state", self.state)):
+            if not value.strip():
+                raise GroundError(f"PersonState.{label} must not be empty.")
+
+
+@dataclass(frozen=True)
+class Correction:
+    """A correction typed by what changed.
+
+    DETAIL: the facts stay the same, a detail was fixed (dates, names,
+    sequence order). CORE-CLAIM: what was claimed to have happened
+    changed. Core-claim changes are the signal — they mark where the
+    account itself shifted.
+    """
+
+    kind: str  # "detail" | "core-claim"
+    text: str
+
+    def __post_init__(self) -> None:
+        if self.kind not in ("detail", "core-claim"):
+            raise GroundError(
+                f"Correction kind must be 'detail' or 'core-claim', got {self.kind!r}."
+            )
+        if not self.text.strip():
+            raise GroundError("Correction text must not be empty.")
+
+
+@dataclass
+class GroundMap:
+    """The audited ground: tensions held, states sequenced, corrections typed."""
+
+    tensions: list[HeldTension] = field(default_factory=list)
+    person_states: list[PersonState] = field(default_factory=list)
+    corrections: list[Correction] = field(default_factory=list)
+
+    def core_claim_changes(self) -> list[Correction]:
+        """The signal: corrections that changed the account itself."""
+        return [c for c in self.corrections if c.kind == "core-claim"]
+
+    def render(self) -> str:
+        lines = ["## Audited ground"]
+        for t in self.tensions:
+            lines.append(f"- Held tension: {t.text}")
+        for p in self.person_states:
+            lines.append(f"- State [{p.when}] {p.person}: {p.state}")
+        for c in self.corrections:
+            lines.append(f"- Correction ({c.kind}): {c.text}")
+        if not (self.tensions or self.person_states or self.corrections):
+            lines.append("- (no ground mapped)")
+        return "\n".join(lines)

fairit/hypotheses.py

@@ -0,0 +1,218 @@
+"""Competing-hypothesis testing — the shared core of this package.
+
+Every candidate evasion (shield vocabulary, fogging, DARVO, passive-voice
+responsibility-dodging, whatever dialect it arrives in) is tested as
+competing hypotheses instead of pre-judged:
+
+- H_OBFUSCATION: the language functions as armor — deflecting
+  responsibility, buying status, or changing the topic.
+- H_GENUINE: the language is a sincere attempt, correlated with
+  accountability.
+- H_BOTH: genuine effort that is also conveniently shielding. Both can be
+  true — and this is the common case.
+- INSUFFICIENT_EVIDENCE: the honest finding when the evidence cannot
+  distinguish the hypotheses. Not a failure.
+
+The load-bearing rule, enforced in code: a hypothesis wins ONLY on
+**discriminating evidence** — observations that would differ between the
+hypotheses. Category membership ("this is therapy-speak", "this is
+corporate language") is never evidence. A record that tries to convict
+on category alone is rejected.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+H_OBFUSCATION = "H-obfuscation"
+H_GENUINE = "H-genuine"
+H_BOTH = "H-both"
+INSUFFICIENT_EVIDENCE = "insufficient-evidence"
+
+VERDICTS = (H_OBFUSCATION, H_GENUINE, H_BOTH, INSUFFICIENT_EVIDENCE)
+DIRECTIONED = (H_OBFUSCATION, H_GENUINE, H_BOTH)
+
+SUPPORT_STATUSES = ("supported", "contested", "unsupported")
+
+
+class HypothesisError(ValueError):
+    """Raised when a hypothesis record breaks the testing rules."""
+
+
+class CategoryPresumptionError(HypothesisError):
+    """Raised when a record tries to convict on category membership alone.
+
+    The old probe (v1) pre-judged whole categories of language as
+    obfuscation. This error is that failure mode, made impossible in code:
+    "therapy-speak" by itself, with no observation attached, is not
+    discriminating evidence of anything.
+    """
+
+
+# Category labels that may contextualize a record but may never stand
+# in for evidence. Lowercase, punctuation-stripped for matching.
+CATEGORY_LABELS = frozenset({
+    "therapy speak", "therapy-speak", "therapyspeak", "self regulation",
+    "self-regulation", "selfregulation",
+    "corporate speak", "corporate-speak", "corporatespeak",
+    "bureaucratic", "bureaucratese", "legalese", "wellness speak",
+    "wellness-speak", "hr speak", "hr-speak",
+})
+
+
+def looks_category_only(text: str) -> bool:
+    """True when an evidence item names a category and observes nothing.
+
+    Heuristic, deliberately conservative: it catches the bare label
+    ("therapy-speak") and the label plus filler words ("uses
+    therapy-speak", "sounds like corporate speak"). Anything with a real
+    observation attached passes — the prose-level judgment ("is this
+    actually discriminating?") stays with the operator, and this check
+    exists to make the *failure mode* impossible, not to certify the
+    good cases.
+    """
+    import re
+    import string
+
+    cleaned = text.strip().lower().translate(
+        str.maketrans(string.punctuation, " " * len(string.punctuation))
+    )
+    cleaned = " ".join(cleaned.split())
+    if cleaned in CATEGORY_LABELS:
+        return True
+    for label in CATEGORY_LABELS:
+        rest = cleaned.replace(label, " ", 1)
+        filler = rest.split()
+        # e.g. "uses therapy-speak" / "sounds like corporate speak"
+        if len(filler) <= 2 and all(
+            w in {"uses", "using", "use", "sounds", "like", "is", "very", "kind",
+                  "of", "sort", "type", "just", "simply"} for w in filler
+        ):
+            return True
+        if re.fullmatch(r"(uses|using|is|sounds like)\s*", rest + " ") or not filler:
+            return True
+    return False
+
+
+@dataclass(frozen=True)
+class DiscriminatingEvidence:
+    """One observation that would differ between the hypotheses.
+
+    `favors` names which hypothesis this observation supports, or
+    "neutral" for an observation that constrains the case without
+    favoring a side (e.g. a timeline fact both hypotheses must fit).
+    """
+
+    text: str
+    favors: str = "neutral"
+
+    def __post_init__(self) -> None:
+        if not self.text.strip():
+            raise HypothesisError("Evidence item text must not be empty.")
+        if self.favors not in DIRECTIONED + ("neutral",):
+            raise HypothesisError(f"Bad evidence direction: {self.favors!r}.")
+        if looks_category_only(self.text):
+            raise CategoryPresumptionError(
+                f"Category membership is not evidence: {self.text!r}. "
+                "Attach an observation — what was said, done, or omitted, "
+                "and what would differ between the hypotheses."
+            )
+
+
+@dataclass(frozen=True)
+class Mechanism:
+    """One candidate tactic, held as a hypothesis with a support status."""
+
+    name: str
+    status: str  # supported | contested | unsupported
+
+    def __post_init__(self) -> None:
+        if self.status not in SUPPORT_STATUSES:
+            raise HypothesisError(f"Bad mechanism status: {self.status!r}.")
+        if not self.name.strip():
+            raise HypothesisError("Mechanism name must not be empty.")
+
+
+@dataclass
+class HypothesisRecord:
+    """The result of testing one candidate evasion.
+
+    - candidate: the responsibility that may be dodged, or the flagged
+      language instance — specific, not a category.
+    - verdict: the best-supported hypothesis, or INSUFFICIENT_EVIDENCE.
+    - evidence: observations that separate the hypotheses.
+    - mechanisms: candidate tactics, each with a support status.
+    - remaining_questions: what evidence would resolve the open
+      hypotheses. Required when the verdict is INSUFFICIENT_EVIDENCE.
+    """
+
+    candidate: str
+    verdict: str
+    evidence: list[DiscriminatingEvidence] = field(default_factory=list)
+    mechanisms: list[Mechanism] = field(default_factory=list)
+    remaining_questions: list[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if self.verdict not in VERDICTS:
+            raise HypothesisError(f"Bad verdict: {self.verdict!r}.")
+        if not self.candidate.strip():
+            raise HypothesisError("Candidate must name the specific evasion or language instance.")
+        self._require_discriminating_evidence()
+
+    def _favors(self, direction: str) -> list[DiscriminatingEvidence]:
+        return [e for e in self.evidence if e.favors == direction]
+
+    def _require_discriminating_evidence(self) -> None:
+        if self.verdict == H_OBFUSCATION and not self._favors(H_OBFUSCATION):
+            raise HypothesisError(
+                "H-obfuscation requires at least one evidence item favoring "
+                "H-obfuscation. Category membership does not count."
+            )
+        if self.verdict == H_GENUINE and not self._favors(H_GENUINE):
+            raise HypothesisError(
+                "H-genuine requires at least one evidence item favoring H-genuine."
+            )
+        if self.verdict == H_BOTH and not (
+            self._favors(H_OBFUSCATION) and self._favors(H_GENUINE)
+        ):
+            raise HypothesisError(
+                "H-both requires discriminating evidence on BOTH sides — "
+                "at least one item favoring H-obfuscation and one favoring "
+                "H-genuine. Otherwise the honest verdict is one of the "
+                "other three."
+            )
+        if self.verdict == INSUFFICIENT_EVIDENCE and not self.remaining_questions:
+            raise HypothesisError(
+                "An insufficient-evidence verdict must name what evidence "
+                "would resolve the open hypotheses."
+            )
+
+    def supports_obfuscation(self) -> bool:
+        """True only for a supported H-obfuscation verdict.
+
+        This is the single gate for the OBFUSCATION evidence tag.
+        Everything else — including suspected-but-untested material —
+        stays CLAIM with a hypothesis marker.
+        """
+        return self.verdict == H_OBFUSCATION and (
+            not self.mechanisms
+            or any(m.status == "supported" for m in self.mechanisms)
+        )
+
+    def summary(self) -> str:
+        lines = [
+            f"Candidate evasion: {self.candidate}",
+            f"Best-supported hypothesis: {self.verdict}",
+            "Discriminating evidence:",
+        ]
+        lines.extend(
+            f"  - [{e.favors}] {e.text}" for e in self.evidence
+        ) or lines.append("  (none)")
+        lines.append("Key mechanisms:")
+        lines.extend(
+            f"  - {m.name} [{m.status}]" for m in self.mechanisms
+        ) or lines.append("  (none)")
+        if self.remaining_questions:
+            lines.append("Remaining questions:")
+            lines.extend(f"  - {q}" for q in self.remaining_questions)
+        return "\n".join(lines)

fairit/ledger.py

@@ -0,0 +1,132 @@
+"""Append-only local ledger. Vendored per tool; stdlib only.
+
+CANONICAL COPY: edit this file, then re-vendor with vendor.sh.
+Do not edit the vendored copies in place.
+
+Privacy rule (non-negotiable): the ledger NEVER stores raw input text.
+Records carry SHA-256 digests of inputs plus structural summaries
+(counts, verdicts, deltas). What happened, and what kind — never the words.
+
+Location: ~/.frontface/<tool>/ledger.jsonl
+  override: FRONTFACE_LEDGER_DIR=<dir>   (ledgers go to <dir>/<tool>/)
+  disable:  FRONTFACE_NO_LEDGER=1         (record() becomes a silent no-op)
+
+The ledger must never break the tool it serves: record() swallows OSError
+and returns False instead of raising.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from datetime import datetime, timezone
+
+try:
+    import fcntl
+except ImportError:  # pragma: no cover — Windows has no fcntl
+    fcntl = None  # type: ignore[assignment]
+
+
+def _base_dir() -> str:
+    return os.environ.get("FRONTFACE_LEDGER_DIR") or os.path.join(
+        os.path.expanduser("~"), ".frontface"
+    )
+
+
+def _disabled() -> bool:
+    return os.environ.get("FRONTFACE_NO_LEDGER") == "1"
+
+
+class Ledger:
+    """One JSONL ledger per tool. Cheap to construct; construct per use."""
+
+    def __init__(self, tool: str) -> None:
+        self.tool = tool
+        self.dir = os.path.join(_base_dir(), tool)
+        self.path = os.path.join(self.dir, "ledger.jsonl")
+
+    @property
+    def version(self) -> str:
+        """The owning package's __version__, resolved lazily."""
+        try:
+            pkg = sys.modules.get(__package__ or "")
+            return str(getattr(pkg, "__version__", "unknown"))
+        except Exception:
+            return "unknown"
+
+    @staticmethod
+    def digest(text: str) -> str:
+        return hashlib.sha256(text.encode("utf-8")).hexdigest()
+
+    def record(
+        self,
+        event: str,
+        summary: dict,
+        *,
+        input_text: str | None = None,
+    ) -> bool:
+        """Append one record. Returns False when disabled or on I/O error.
+
+        Never raises. Never stores raw input text — only its digest.
+        """
+        if _disabled():
+            return False
+        rec: dict = {
+            "ts": datetime.now(timezone.utc).isoformat(),
+            "tool": self.tool,
+            "tool_version": self.version,
+            "event": event,
+            "summary": summary,
+        }
+        if input_text is not None:
+            rec["input_digest"] = self.digest(input_text)
+        try:
+            os.makedirs(self.dir, exist_ok=True)
+            with open(self.path, "a", encoding="utf-8") as f:
+                if fcntl is not None:
+                    fcntl.flock(f, fcntl.LOCK_EX)
+                    try:
+                        f.write(json.dumps(rec) + "\n")
+                        f.flush()
+                        os.fsync(f.fileno())
+                    finally:
+                        fcntl.flock(f, fcntl.LOCK_UN)
+                else:
+                    f.write(json.dumps(rec) + "\n")
+        except OSError:
+            return False
+        return True
+
+    def read(self, limit: int | None = None) -> list[dict]:
+        """All records, oldest first. Empty list when there's no ledger."""
+        try:
+            with open(self.path, encoding="utf-8") as f:
+                lines = f.read().splitlines()
+        except OSError:
+            return []
+        recs = []
+        for line in lines:
+            line = line.strip()
+            if line:
+                try:
+                    recs.append(json.loads(line))
+                except ValueError:
+                    continue  # never let a corrupt line kill the read
+        return recs[-limit:] if limit else recs
+
+    def summary(self) -> dict:
+        """Counts by event plus first/last timestamps."""
+        recs = self.read()
+        by_event: dict[str, int] = {}
+        for r in recs:
+            ev = str(r.get("event", "?"))
+            by_event[ev] = by_event.get(ev, 0) + 1
+        return {
+            "tool": self.tool,
+            "records": len(recs),
+            "events": by_event,
+            "first": recs[0]["ts"] if recs else None,
+            "last": recs[-1]["ts"] if recs else None,
+        }

fairit/overlay.py

@@ -0,0 +1,184 @@
+"""The evasion-probe protocol: test, never presume.
+
+This is the front-facing form of the two skills being converted together:
+
+- responsibility-obfuscation-probe: every candidate evasion becomes
+  competing hypotheses tested against discriminating evidence.
+- field-forge's probe stage: the same protocol, generalized past
+  therapy-speak to any shield dialect (corporate, bureaucratic).
+
+One implementation, two consumers — the overlap the assessment flagged
+is structural, and this module is the single place the protocol lives.
+
+The probe's outputs:
+- ObfuscatedObject: the responsibility that MAY be dodged, with a
+  support status (supported / contested / unsupported) — never a verdict.
+- JargonFlag: one instance of possibly-evasive vocabulary, run through
+  H-obfuscation / H-genuine / H-both against discriminating evidence.
+- The evidence tag for a record: OBFUSCATION only when H-obfuscation is
+  supported by discriminating evidence; otherwise CLAIM with a
+  hypothesis marker. Suspected-but-untested material is never upgraded
+  on category membership alone.
+
+The probe never collides, adjudicates, refines, or extracts surprise.
+Its output feeds whatever comes next (the interrogation engine's
+Diverge phase, or the operator's own judgment) as hypothesis-tagged
+material.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .dialects import DIALECTS, detect_markers
+from .evidence import OBFUSCATION, CLAIM, normalize_tag
+from .ledger import Ledger
+from .hypotheses import (
+    H_OBFUSCATION,
+    H_GENUINE,
+    H_BOTH,
+    INSUFFICIENT_EVIDENCE,
+    SUPPORT_STATUSES,
+    DiscriminatingEvidence,
+    HypothesisRecord,
+    Mechanism,
+)
+
+
+class ProbeError(ValueError):
+    """Raised when probe input breaks the protocol."""
+
+
+@dataclass(frozen=True)
+class JargonFlag:
+    """One instance of possibly-evasive vocabulary, under test.
+
+    `dialect` names where the shield vocabulary came from; `record`
+    carries the actual hypothesis test. A flag with no test attached is
+    incomplete — detection without testing is exactly the v1 failure
+    mode this package exists to prevent.
+    """
+
+    phrase: str
+    dialect: str
+    record: HypothesisRecord
+
+    def __post_init__(self) -> None:
+        if not self.phrase.strip():
+            raise ProbeError("Jargon flag needs the flagged phrase.")
+        if self.dialect not in DIALECTS:
+            raise ProbeError(
+                f"Unknown dialect {self.dialect!r}. Known: {', '.join(DIALECTS)}."
+            )
+
+
+@dataclass(frozen=True)
+class ObfuscatedObject:
+    """The responsibility that may be dodged — a hypothesis, not a verdict."""
+
+    candidate: str
+    support: str  # supported | contested | unsupported
+    apparent_function: str = ""  # what the evasion would achieve if real
+
+    def __post_init__(self) -> None:
+        if not self.candidate.strip():
+            raise ProbeError("Obfuscated-object candidate must not be empty.")
+        if self.support not in SUPPORT_STATUSES:
+            raise ProbeError(f"Bad support status: {self.support!r}.")
+
+
+def run_jargon_test(
+    phrase: str,
+    dialect: str,
+    evidence_for_obfuscation: str,
+    evidence_for_genuine: str,
+    *,
+    mechanisms: list[Mechanism] | None = None,
+    remaining_questions: list[str] | None = None,
+) -> JargonFlag:
+    """Run one jargon instance through the hypothesis protocol.
+
+    Both hypotheses are tested against discriminating evidence. When the
+    evidence favors one side, that hypothesis wins; when it favors both,
+    the honest verdict is H-both; when it can't distinguish them, the
+    honest verdict is insufficient-evidence — never a verdict.
+    """
+    has_obf = bool(evidence_for_obfuscation.strip())
+    has_gen = bool(evidence_for_genuine.strip())
+    if has_obf and not has_gen:
+        verdict = H_OBFUSCATION
+        evidence = [DiscriminatingEvidence(evidence_for_obfuscation, H_OBFUSCATION)]
+    elif has_gen and not has_obf:
+        verdict = H_GENUINE
+        evidence = [DiscriminatingEvidence(evidence_for_genuine, H_GENUINE)]
+    elif has_obf and has_gen:
+        verdict = H_BOTH
+        evidence = [
+            DiscriminatingEvidence(evidence_for_obfuscation, H_OBFUSCATION),
+            DiscriminatingEvidence(evidence_for_genuine, H_GENUINE),
+        ]
+    else:
+        verdict = INSUFFICIENT_EVIDENCE
+        evidence = []
+        if not remaining_questions:
+            remaining_questions = [
+                "What observation would distinguish H-obfuscation from "
+                "H-genuine here? (e.g. does the language appear only under "
+                "pressure? is it followed by accountability or topic change?)"
+            ]
+    record = HypothesisRecord(
+        candidate=f"the phrase {phrase!r} may function as evasion",
+        verdict=verdict,
+        evidence=evidence,
+        mechanisms=list(mechanisms or []),
+        remaining_questions=list(remaining_questions or []),
+    )
+    Ledger("fairit").record(
+        "jargon_test",
+        {
+            "dialect": dialect,
+            "verdict": verdict,
+            "mechanisms": len(mechanisms or []),
+            "evidence_items": len(evidence),
+        },
+        input_text=phrase,
+    )
+    return JargonFlag(phrase=phrase, dialect=dialect, record=record)
+
+
+def scan_and_test(
+    text: str,
+    evidence: dict[str, tuple[str, str]],
+) -> list[JargonFlag]:
+    """Detect shield vocabulary in text and run each hit through the protocol.
+
+    `evidence` maps each detected phrase to
+    (evidence_for_obfuscation, evidence_for_genuine). A hit with no
+    supplied evidence gets the insufficient-evidence verdict — the probe
+    refuses to test-free convict OR exonerate on detection alone.
+    """
+    flags: list[JargonFlag] = []
+    for dialect, phrase in detect_markers(text):
+        for_obf, for_gen = evidence.get(phrase, ("", ""))
+        flags.append(
+            run_jargon_test(
+                phrase, dialect, for_obf, for_gen,
+                remaining_questions=[
+                    "What evidence would distinguish obfuscation from "
+                    "genuine use here?"
+                ] if not (for_obf.strip() or for_gen.strip()) else [],
+            )
+        )
+    return flags
+
+
+def evidence_tag_for(record: HypothesisRecord, *, probe_ran: bool = True) -> str:
+    """The evidence tag a record earns.
+
+    OBFUSCATION only when the probe ran and H-obfuscation is supported
+    by discriminating evidence. Everything else stays CLAIM — with a
+    hypothesis marker, so downstream consumers know a test was run.
+    """
+    if probe_ran and record.supports_obfuscation():
+        return normalize_tag(OBFUSCATION, probe_ran=True)
+    return normalize_tag(CLAIM)

fairit-1.0.0.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: fairit
+Version: 1.0.0
+Summary: Ground mapping and evasion-hypothesis testing: hold the state, test the language, hand off the seeds. Never presumes evasion.
+Author: Ryan Wesley Hitchcock
+License: MIT
+Project-URL: Homepage, https://github.com/ohpersonperson/frontface
+Keywords: hypothesis-testing,evasion,audit,interrogation,evidence
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# fairit — ground mapping and evasion-hypothesis testing
+
+Tests whether evasive-looking communication is actually evading
+anything — and if so, what. It never presumes evasion. Three stages:
+
+1. **Ground mapping.** Establish the exact situational state without
+   forcing narrative resolution: opposing facts as parallel,
+   non-subordinating sentences ("X is true. Y is also true." — never
+   "X, but Y"), people as time-indexed states, every correction typed
+   as detail vs core-claim.
+2. **Evasion-hypothesis testing.** Every candidate evasion — therapy-speak,
+   corporate-speak, bureaucratic passive voice, fogging, DARVO,
+   projection — becomes competing hypotheses: **H-obfuscation /
+   H-genuine / H-both**, tested against discriminating evidence.
+3. **Handoff.** 2–3 seed frames plus the audited ground, handed to
+   whatever comes next. Then the package stands down.
+
+The one rule everything else serves: **a hypothesis wins only on
+discriminating evidence** — observations that would differ between the
+hypotheses. Category membership ("this is therapy-speak") is never
+evidence. "Insufficient evidence to distinguish" is an honest finding,
+not a failure.
+
+No prerequisites. The mechanism is the whole product. No model, no
+network — this is pure machinery. The operator (human or model) supplies
+the evidence; the library enforces the testing discipline.
+
+*(Lineage: the front-facing conversion of two skills from Ryan's
+skill-suite, MIT — `responsibility-obfuscation-probe` and `field-forge`,
+converted as one unit because they share one hypothesis-testing core.
+What changed in the conversion is documented in CHANGELOG.md.)*
+
+## Quickstart
+
+```python
+from fairit import scan_and_test, evidence_tag_for
+
+text = "Mistakes were made in the scoping phase. We're going to circle back."
+flags = scan_and_test(text, {
+    "mistakes were made": (
+        "the passive phrasing names no actor; internal emails name the PM "
+        "who cut scoping short — the actor is known",
+        "",
+    ),
+    "circle back": (
+        "used to end the paragraph about the miss without giving a new date",
+        "",
+    ),
+})
+for flag in flags:
+    print(flag.phrase, "->", flag.record.verdict, "->", evidence_tag_for(flag.record))
+# mistakes were made -> H-obfuscation -> OBFUSCATION
+# circle back -> H-obfuscation -> OBFUSCATION
+```
+
+Full cycle demo (ground → probe → brief), no model needed:
+
+```bash
+cd probe-forge
+PYTHONPATH=src python3 examples/run_cycle.py
+```
+
+## What it does
+
+**Ground mapping** (`ground.py`) — the pre-interrogation audit:
+
+- Held tensions must be parallel non-subordinating sentences. The
+  subordinating-conjunction scan is in code: "promised a refund, *but*
+  none arrived" is rejected; "promised a refund. None arrived." passes.
+- People are time-indexed states, never one flat characterization.
+- Corrections are typed detail vs core-claim. Core-claim changes — the
+  account itself shifting — are the signal, and the library surfaces
+  them.
+
+**Hypothesis testing** (`hypotheses.py`) — the shared core:
+
+- Four verdicts: H-obfuscation, H-genuine, H-both, insufficient-evidence.
+- Code-enforced rules: H-obfuscation needs ≥1 evidence item favoring it;
+  H-both needs evidence on *both* sides; insufficient-evidence must name
+  what would resolve the open hypotheses.
+- The category-presumption check: evidence that only names a category
+  ("therapy-speak", "uses corporate speak") is rejected with
+  `CategoryPresumptionError`. This is the old probe's failure mode
+  (pre-judging therapy-speak as armor), made impossible in code.
+
+**Probe protocol** (`overlay.py`) — jargon in three dialects (therapy,
+corporate, bureaucratic; see `dialects.py`):
+
+- Detection produces *candidates*, never verdicts. A detected phrase with
+  no evidence gets insufficient-evidence — the probe refuses to convict
+  *or* exonerate on detection alone.
+- The evidence tag: **OBFUSCATION** only when H-obfuscation is supported
+  by discriminating evidence. Everything else stays **CLAIM** with a
+  hypothesis marker. Suspected-but-untested material is never upgraded
+  on category membership alone.
+
+**Audit brief** (`brief.py`) — the output artifact with frontmatter
+(`artifact:`, `date:`, `protocol:`, `lifecycle:`), Markdown
+render/parse, and the stand-down rule enforced in code: the brief must
+never contain collision, adjudication, refinement, or surprise sections.
+Those belong to the interrogation engine. If the engine isn't running,
+the brief is reported and the work stops.
+
+**Evidence taxonomy** (`evidence.py`) — one authoritative mapping.
+field-forge shipped an 8-tier list; the interrogation engine uses 11
+tags (10 core + overlay-only OBFUSCATION). The forge's 8 map 1:1 onto
+the engine's; the 3 the forge never named (HYPOTHESIS, REQUIREMENT,
+DEPENDENCY) are documented as recognized. `check_matches_engine()`
+guards against silent forks when the sibling package is importable.
+
+## What's honest about the limits
+
+- The library cannot prove a counter-hypothesis is *strong* — the
+  evidence-quality judgment stays with the operator. What it makes
+  impossible is the failure modes: verdicts without discriminating
+  evidence, category-based presumption, silent upgrades to OBFUSCATION,
+  subordinated tensions, and the overlay doing the engine's job.
+- The dialog procedure (asking for raw input, precision-forcing
+  questions) is an operator protocol, documented in the examples — it
+  isn't codeable without a model in the loop, and isn't pretended to be.
+
+## Tests
+
+```bash
+PYTHONPATH=src python3 -m unittest discover -s tests
+```
+
+55 offline tests: verdict rules, category-presumption rejection (the v1
+regression suite), the OBFUSCATION gate, the subordinator scan,
+correction typing, taxonomy reconciliation, brief round-trip and
+stand-down, dialect detection, and a full ground→probe→brief cycle.

fairit-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+fairit/__init__.py,sha256=AI34I3fLf4eVUQJAWDTmN3_dqbVBUV7Jhj_7y_QiDpQ,1869
+fairit/brief.py,sha256=7xKpMgRPGK1XsFo201BpN3me_BIIUg7CfJmMZ6fXodc,4903
+fairit/dialects.py,sha256=yY8S4U28TJ4VK9VyJ2st5DHbk-eBU-06Hz18DiLqg24,2136
+fairit/evidence.py,sha256=NxQhEkinxy96d_KhsFDjTNdNgtuuQPzm0ixRUf4AsGc,6854
+fairit/ground.py,sha256=-U6vh9buouy3s5NTRq0z54gKL3yT0oC0TMP7BA_hFw0,4335
+fairit/hypotheses.py,sha256=RVoOqDpnkK-pBSYdrp3_guUAxF3klC94hS-_vAqBdPI,8749
+fairit/ledger.py,sha256=x8TH2et1Jt_UTzLMn49R8YKEiMMykYTW6UoMz-l8qCU,4245
+fairit/overlay.py,sha256=EgF5AB82gF778e3zZdvOb3WEcmaEoJGnB4rC13NijkY,6713
+fairit-1.0.0.dist-info/licenses/LICENSE,sha256=Zx_XafyZDq7qBexUb7tER9kYlBZ0rCVaAwKuqMCfxLE,1078
+fairit-1.0.0.dist-info/METADATA,sha256=cQ0JYmymqqmFucs45s0HEBnuZbKkEKFqhIp5Wrb0s78,6496
+fairit-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+fairit-1.0.0.dist-info/top_level.txt,sha256=3abimNla0_0zZJ5Cj3UWU_9zUMRQx44En85ySkDCmkg,7
+fairit-1.0.0.dist-info/RECORD,,

fairit-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fairit-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ryan Wesley Hitchcock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

fairit-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fairit