fairit 1.0.0__tar.gz

fairit-1.0.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,131 @@
+# 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/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fairit"
+version = "1.0.0"
+description = "Ground mapping and evasion-hypothesis testing: hold the state, test the language, hand off the seeds. Never presumes evasion."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Ryan Wesley Hitchcock" }]
+keywords = ["hypothesis-testing", "evasion", "audit", "interrogation", "evidence"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/ohpersonperson/frontface"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

fairit-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

fairit-1.0.0/src/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-1.0.0/src/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-1.0.0/src/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