postmo 1.0.0__tar.gz

postmo-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.

postmo-1.0.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: postmo
+Version: 1.0.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
+Project-URL: Homepage, https://github.com/ohpersonperson/frontface
+Keywords: audit,contradiction,linter,evidence,interrogation
+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
+
+# postmo — hold the mess, don't resolve it
+
+An audit is not a narrative. A narrative resolves tension toward a
+single coherent story; an audit holds the actual shape of what's been
+said — including the parts that don't resolve — and tracks it
+accurately as it changes.
+
+Five disciplines, enforced where they're mechanical and explicit
+protocol where they need judgment:
+
+1. **Hold contradictions as contradictions.** "I adored her and I'm
+   furious at her" stays two live halves — never "X, but Y", never a
+   synthesized third thing, never flagged as a problem needing
+   resolution.
+2. **Track people as time-indexed states, not verdicts.** Tuesday-her
+   and Thursday-her are both real. Nobody is "a liar" as a fixed label.
+3. **Type every correction: detail vs core-claim.** A fixed date doesn't
+   reopen standing claims; a withdrawn accusation is the signal.
+4. **Never supply motive the teller didn't state.** "He tackled you
+   because he panicked" is invented, even if plausible. Observed
+   sequence only — who did what, in what order.
+5. **Self-check for softening.** Did "betrayal" become "mistake"? Did a
+   restatement tidy the account? Did ambivalence get resolved into one
+   "real" feeling? The noticing is part of the deliverable.
+
+No prerequisites. No model, no network — the operator (human or model)
+supplies the material; the library enforces the discipline. The
+mechanism is the whole product.
+
+*(Lineage: the front-facing conversion of the `forensic-situational-audit`
+skill from Ryan's skill-suite, MIT. What changed is documented in
+CHANGELOG.md — the name, the "field" language, and prose rules turned
+into checked code.)*
+
+## What it does
+
+Two modes:
+
+- **Direct audit (the headline).** "Don't resolve this, just hold it."
+  The operator works a messy multi-person situation conversationally;
+  the package scans drafts for discipline violations and accumulates
+  the audit record. No engine, no interrogation.
+- **Overlay.** Attaches to the interrogation engine's Decompose phase
+  (disciplines 2–4) and Collide phase (disciplines 1, 5 — the strict
+  enforcer: no subordinating conjunctions, no synthesized third thing).
+  The overlay never resolves, never synthesizes, never converts a
+  direct audit into an interrogation unasked.
+
+The canonical artifact is the **audit record**: which disciplines
+fired, held tensions, person-state sequences, typed corrections,
+softening and motive flags — structured data with timestamps that the
+next session can load and continue from. Machine-readable first
+(`record.render()`), renderable conversationally
+(`record.render_conversation()`).
+
+## Why it works
+
+Most "holding space" collapses into narrative smoothing — the grammar
+does the resolving before anyone notices. The audit attacks that
+mechanically:
+
+- **The subordinator scan** rejects "X, but/however/which means Y" in
+  held tensions. The "but" demotes one side; the audit refuses to hold
+  a tension that's already been resolved in grammar.
+- **The motive scan** flags causal attributions with no teller
+  attribution ("because he panicked") while passing attributed ones
+  ("he said he panicked") and keeping marked guesses marked.
+- **The softening scan** compares the teller's words against
+  restatements: downgrade wordlist ("betrayal" → "mistake"), dropped
+  strong terms, tidy-restatement phrases ("so what you're saying is"),
+  ambivalence-resolution phrases ("the real feeling is").
+- **The stand-down rule** is schema-level: the record rejects
+  synthesis/resolution/verdict sections. An audit that resolves has
+  stopped auditing.
+
+What the scans can't do stays explicitly operator protocol — each
+discipline's table entry (`disciplines.py`) marks the code/operator
+split. A fired check is a finding; a quiet check is not a clean bill
+of health.
+
+## Quickstart
+
+Zero dependencies beyond Python 3.10+. Fully offline.
+
+```bash
+cd audit
+PYTHONPATH=src python3 -m unittest discover -s tests   # 55 offline tests
+```
+
+Lint an audit draft:
+
+```bash
+PYTHONPATH=src python3 examples/lint_audit.py --text examples/bad-draft.txt \
+    --restatement examples/bad-restatement.txt
+```
+
+Build a record in code:
+
+```python
+from postmo import (
+    AuditRecord, HeldTension, PersonState, Correction, scan_text,
+)
+
+rec = AuditRecord(case_name="Warehouse shift dispute")
+rec.tensions.append(HeldTension(text=(
+    "Dana says the pallet was already damaged. "
+    "Marco says it was intact.")))
+rec.states.append(PersonState(when="2026-09-18", person="Dana",
+                              state="calm, cooperative"))
+rec.corrections.append(Correction(kind="core-claim",
+    text="Marco withdrew the claim that Dana hid the damage."))
+rec.log(1, "enforced", "1 tension held as parallel sentences")
+
+report = scan_text("He tackled you because he panicked.")
+for flag in report.motive_flags:
+    print(flag.severity, ":", flag.sentence)
+
+print(rec.render())              # the machine-readable record
+print(rec.render_conversation()) # the human surface
+
+# Next session:
+from postmo import parse
+rec2 = parse(rec.render())  # everything survives the round trip
+```
+
+## Inputs, outputs
+
+- **Input:** situation material (prose), held tensions, person-state
+  observations, corrections, restatements to check.
+- **Output:** a `ScanReport` (REVIEW items per discipline), and/or a
+  rendered `audit-record` Markdown document — complete, timestamped,
+  parseable back into the full structured record.
+
+## Worked examples
+
+- `examples/example-1-workplace-dispute.md` — a full direct-audit
+  cycle on a neutral workplace dispute, all five disciplines, record
+  and conversational surface.
+- `examples/example-2-lint-flags.md` — the linter catching a bad
+  audit draft, flag by flag.
+
+*Both situations are constructed for teaching — they show the audit's
+shape, not real findings.*
+
+## Overlap with evasion_audit (documented, not imported)
+
+Disciplines 1–3 mirror the ground-mapping in `evasion_audit`
+(the probe+forge conversion): the subordinator wordlist, the
+`HeldTension` / `PersonState` / `Correction` records are intentionally
+identical. This package stays standalone and dependency-free, so the
+definitions are duplicated rather than imported — the wordlists match
+so the two packages can't silently disagree. The evidence taxonomy is
+the same 11-tag set all three packages share, vendored here with the
+`check_matches_engine()` fork guard.
+
+## FAQ
+
+**Does it need the interrogation engine?** No. Direct audit mode is
+standalone and is the headline use. Overlay mode attaches to engine
+phases; with no engine running, the overlay reports the record and
+stops.
+
+**Does it resolve anything?** Never. That's the stand-down rule, and
+it's enforced in code, not just in prose.
+
+**What does it cost?** Nothing. Stdlib only, no model calls, no network.
+
+## License
+
+MIT. See LICENSE.

postmo-1.0.0/README.md

@@ -0,0 +1,170 @@
+# postmo — hold the mess, don't resolve it
+
+An audit is not a narrative. A narrative resolves tension toward a
+single coherent story; an audit holds the actual shape of what's been
+said — including the parts that don't resolve — and tracks it
+accurately as it changes.
+
+Five disciplines, enforced where they're mechanical and explicit
+protocol where they need judgment:
+
+1. **Hold contradictions as contradictions.** "I adored her and I'm
+   furious at her" stays two live halves — never "X, but Y", never a
+   synthesized third thing, never flagged as a problem needing
+   resolution.
+2. **Track people as time-indexed states, not verdicts.** Tuesday-her
+   and Thursday-her are both real. Nobody is "a liar" as a fixed label.
+3. **Type every correction: detail vs core-claim.** A fixed date doesn't
+   reopen standing claims; a withdrawn accusation is the signal.
+4. **Never supply motive the teller didn't state.** "He tackled you
+   because he panicked" is invented, even if plausible. Observed
+   sequence only — who did what, in what order.
+5. **Self-check for softening.** Did "betrayal" become "mistake"? Did a
+   restatement tidy the account? Did ambivalence get resolved into one
+   "real" feeling? The noticing is part of the deliverable.
+
+No prerequisites. No model, no network — the operator (human or model)
+supplies the material; the library enforces the discipline. The
+mechanism is the whole product.
+
+*(Lineage: the front-facing conversion of the `forensic-situational-audit`
+skill from Ryan's skill-suite, MIT. What changed is documented in
+CHANGELOG.md — the name, the "field" language, and prose rules turned
+into checked code.)*
+
+## What it does
+
+Two modes:
+
+- **Direct audit (the headline).** "Don't resolve this, just hold it."
+  The operator works a messy multi-person situation conversationally;
+  the package scans drafts for discipline violations and accumulates
+  the audit record. No engine, no interrogation.
+- **Overlay.** Attaches to the interrogation engine's Decompose phase
+  (disciplines 2–4) and Collide phase (disciplines 1, 5 — the strict
+  enforcer: no subordinating conjunctions, no synthesized third thing).
+  The overlay never resolves, never synthesizes, never converts a
+  direct audit into an interrogation unasked.
+
+The canonical artifact is the **audit record**: which disciplines
+fired, held tensions, person-state sequences, typed corrections,
+softening and motive flags — structured data with timestamps that the
+next session can load and continue from. Machine-readable first
+(`record.render()`), renderable conversationally
+(`record.render_conversation()`).
+
+## Why it works
+
+Most "holding space" collapses into narrative smoothing — the grammar
+does the resolving before anyone notices. The audit attacks that
+mechanically:
+
+- **The subordinator scan** rejects "X, but/however/which means Y" in
+  held tensions. The "but" demotes one side; the audit refuses to hold
+  a tension that's already been resolved in grammar.
+- **The motive scan** flags causal attributions with no teller
+  attribution ("because he panicked") while passing attributed ones
+  ("he said he panicked") and keeping marked guesses marked.
+- **The softening scan** compares the teller's words against
+  restatements: downgrade wordlist ("betrayal" → "mistake"), dropped
+  strong terms, tidy-restatement phrases ("so what you're saying is"),
+  ambivalence-resolution phrases ("the real feeling is").
+- **The stand-down rule** is schema-level: the record rejects
+  synthesis/resolution/verdict sections. An audit that resolves has
+  stopped auditing.
+
+What the scans can't do stays explicitly operator protocol — each
+discipline's table entry (`disciplines.py`) marks the code/operator
+split. A fired check is a finding; a quiet check is not a clean bill
+of health.
+
+## Quickstart
+
+Zero dependencies beyond Python 3.10+. Fully offline.
+
+```bash
+cd audit
+PYTHONPATH=src python3 -m unittest discover -s tests   # 55 offline tests
+```
+
+Lint an audit draft:
+
+```bash
+PYTHONPATH=src python3 examples/lint_audit.py --text examples/bad-draft.txt \
+    --restatement examples/bad-restatement.txt
+```
+
+Build a record in code:
+
+```python
+from postmo import (
+    AuditRecord, HeldTension, PersonState, Correction, scan_text,
+)
+
+rec = AuditRecord(case_name="Warehouse shift dispute")
+rec.tensions.append(HeldTension(text=(
+    "Dana says the pallet was already damaged. "
+    "Marco says it was intact.")))
+rec.states.append(PersonState(when="2026-09-18", person="Dana",
+                              state="calm, cooperative"))
+rec.corrections.append(Correction(kind="core-claim",
+    text="Marco withdrew the claim that Dana hid the damage."))
+rec.log(1, "enforced", "1 tension held as parallel sentences")
+
+report = scan_text("He tackled you because he panicked.")
+for flag in report.motive_flags:
+    print(flag.severity, ":", flag.sentence)
+
+print(rec.render())              # the machine-readable record
+print(rec.render_conversation()) # the human surface
+
+# Next session:
+from postmo import parse
+rec2 = parse(rec.render())  # everything survives the round trip
+```
+
+## Inputs, outputs
+
+- **Input:** situation material (prose), held tensions, person-state
+  observations, corrections, restatements to check.
+- **Output:** a `ScanReport` (REVIEW items per discipline), and/or a
+  rendered `audit-record` Markdown document — complete, timestamped,
+  parseable back into the full structured record.
+
+## Worked examples
+
+- `examples/example-1-workplace-dispute.md` — a full direct-audit
+  cycle on a neutral workplace dispute, all five disciplines, record
+  and conversational surface.
+- `examples/example-2-lint-flags.md` — the linter catching a bad
+  audit draft, flag by flag.
+
+*Both situations are constructed for teaching — they show the audit's
+shape, not real findings.*
+
+## Overlap with evasion_audit (documented, not imported)
+
+Disciplines 1–3 mirror the ground-mapping in `evasion_audit`
+(the probe+forge conversion): the subordinator wordlist, the
+`HeldTension` / `PersonState` / `Correction` records are intentionally
+identical. This package stays standalone and dependency-free, so the
+definitions are duplicated rather than imported — the wordlists match
+so the two packages can't silently disagree. The evidence taxonomy is
+the same 11-tag set all three packages share, vendored here with the
+`check_matches_engine()` fork guard.
+
+## FAQ
+
+**Does it need the interrogation engine?** No. Direct audit mode is
+standalone and is the headline use. Overlay mode attaches to engine
+phases; with no engine running, the overlay reports the record and
+stops.
+
+**Does it resolve anything?** Never. That's the stand-down rule, and
+it's enforced in code, not just in prose.
+
+**What does it cost?** Nothing. Stdlib only, no model calls, no network.
+
+## License
+
+MIT. See LICENSE.

postmo-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "postmo"
+version = "1.0.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" }
+requires-python = ">=3.10"
+authors = [{ name = "Ryan Wesley Hitchcock" }]
+keywords = ["audit", "contradiction", "linter", "evidence", "interrogation"]
+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"]

postmo-1.0.0/setup.cfg

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

postmo-1.0.0/src/postmo/__init__.py

@@ -0,0 +1,49 @@
+"""postmo — hold a messy situation without resolving it.
+
+Five audit disciplines, enforced as a linter where they're mechanical
+and as explicit operator protocol where they need judgment:
+
+1. Hold contradictions as contradictions (parallel sentences, never "X, but Y").
+2. Track people as time-indexed states, never categorical verdicts.
+3. Type every correction: detail vs core-claim.
+4. Never supply motive or causality the teller didn't state.
+5. Self-check every output for softened threat language, supplied
+   generous interpretations, dropped contradictions, resolved ambivalence.
+
+Two modes: direct audit (the headline — "don't resolve this, just hold
+it", no engine needed) and overlay on the interrogation engine's
+Decompose/Collide phases. Either way the canonical artifact is the
+audit record: full structured data the next session can load, with
+timestamps. The audit never resolves — the record schema rejects
+synthesis/resolution/verdict sections.
+"""
+
+from .disciplines import DISCIPLINES, D1, D2, D3, D4, D5, discipline_name
+from .evidence import (
+    EvidenceError, EvidenceItem, check_matches_engine, normalize_tag, tag_list,
+)
+from .overlay import NEVER, attachment_for, describe_contract
+from .record import (
+    PROTOCOL, AuditRecord, DisciplineEntry, RecordError, check_stand_down, parse,
+    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,
+)
+
+__all__ = [
+    "DISCIPLINES", "D1", "D2", "D3", "D4", "D5", "discipline_name",
+    "EvidenceError", "EvidenceItem", "check_matches_engine",
+    "normalize_tag", "tag_list",
+    "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",
+    "find_correction_candidates", "find_subordinators", "find_verdict_words",
+    "scan_text",
+]

postmo-1.0.0/src/postmo/disciplines.py

@@ -0,0 +1,138 @@
+"""The five audit disciplines, stated once.
+
+An audit is not a narrative: a narrative resolves tension toward a
+single coherent story; an audit holds the actual shape of what's been
+said — including the parts that don't resolve — and tracks it
+accurately as it changes.
+
+Each discipline carries its code/operator split explicitly:
+`mechanical` is what `scans.py` checks; `operator` is what needs a
+human or model judgment and stays protocol, not code. The split is
+honest, not aspirational — a mechanical check that fired is a finding;
+an operator check is a responsibility.
+"""
+
+from __future__ import annotations
+
+D1 = 1  # hold contradictions as contradictions
+D2 = 2  # track person-state as time-indexed, not categorical
+D3 = 3  # distinguish detail-correction from core-claim correction
+D4 = 4  # don't supply motive or causality the teller didn't state
+D5 = 5  # self-check for softening and evasion — including your own
+
+DISCIPLINES: dict[int, dict[str, str]] = {
+    D1: {
+        "name": "hold-contradictions",
+        "rule": (
+            "When two stated things are in tension, do not pick one side, "
+            "do not synthesize a third thing that subordinates one to the "
+            "other, and do not flag the tension as a problem needing "
+            "resolution. Both halves stay live. If a synthesis is true, "
+            "the teller states it — never supply it on their behalf."
+        ),
+        "mechanical": (
+            "Held tensions must be parallel non-subordinating sentences "
+            "('X is true. Y is also true.') — the subordinator scan in "
+            "scans.py rejects 'X, but/however/which means Y'."
+        ),
+        "operator": (
+            "Recognizing that two statements ARE in tension (the scan "
+            "checks grammar, not meaning); refusing to tidy the tension "
+            "in surrounding prose; leaving silence where no resolving "
+            "sentence is needed."
+        ),
+    },
+    D2: {
+        "name": "time-indexed-person-states",
+        "rule": (
+            "People are not 'good' or 'bad', 'safe' or 'dangerous' as fixed "
+            "labels — they are in different states at different points, and "
+            "all of those states are real simultaneously. Summarize "
+            "sequences of states, never verdicts on persons."
+        ),
+        "mechanical": (
+            "PersonState requires when + person + state, all non-empty; "
+            "the verdict-word scan flags permanent-label language "
+            "('he is a liar') for operator review."
+        ),
+        "operator": (
+            "Resisting the pull to declare one state 'the mask' and another "
+            "'the truth'; keeping the sequence ordered and complete."
+        ),
+    },
+    D3: {
+        "name": "correction-typing",
+        "rule": (
+            "Detail correction: a particular fact is revised (a time, an "
+            "object, a peripheral sequence detail) — it does not touch any "
+            "core claim standing elsewhere. Core-claim correction: a "
+            "decision, boundary, conclusion, or central assertion is "
+            "revised. Never let a detail correction trigger re-litigation "
+            "of an uncorrected core claim. If ambiguous which kind, ask "
+            "rather than guess."
+        ),
+        "mechanical": (
+            "Correction records accept only 'detail' or 'core-claim'; the "
+            "correction-candidate scan flags correction-like sentences "
+            "('actually…', 'no wait…', 'to be clear…') that haven't been "
+            "typed yet."
+        ),
+        "operator": (
+            "Typing ambiguous corrections (ask, don't guess); holding the "
+            "line that a detail fix does not reopen standing core claims."
+        ),
+    },
+    D4: {
+        "name": "no-supplied-motive",
+        "rule": (
+            "Track what happened and what was said — not why, unless the "
+            "teller assigns the why. 'He tackled you because he panicked' "
+            "is an invented motive, even if plausible. State the observed "
+            "sequence: who did what, in what order. A directly requested "
+            "read on motive is a flagged guess ('if I had to guess…'), "
+            "never narrated as settled fact."
+        ),
+        "mechanical": (
+            "The motive scan flags causal/motive attributions ('because he "
+            "panicked', 'driven by', 'in order to') that carry no "
+            "attribution marker ('he said', 'according to', quotes) and no "
+            "explicit guess-flag."
+        ),
+        "operator": (
+            "The final call on whether a flagged attribution was actually "
+            "supplied by the teller in surrounding context the scan can't "
+            "see; keeping flagged guesses flagged."
+        ),
+    },
+    D5: {
+        "name": "softening-self-check",
+        "rule": (
+            "Before finalizing, check: did a threat/betrayal/harm get "
+            "gentler language than the teller used? Did a generous "
+            "interpretation get supplied unasked? Did a restatement drop a "
+            "contradiction or tidy it? Did ambivalence get resolved into "
+            "one 'real' feeling? Did a direct question get answered "
+            "evasively? The noticing is part of the deliverable. Also runs "
+            "outward: name the teller's own smoothing once, plainly, "
+            "without diagnosing — don't press, don't repeat if unpicked."
+        ),
+        "mechanical": (
+            "The softening scan compares original vs restatement: "
+            "downgrade wordlist ('betrayal' → 'mistake'), dropped strong "
+            "terms, tidy-restatement phrases ('so what you're saying is'), "
+            "ambivalence-resolution phrases ('the real feeling is')."
+        ),
+        "operator": (
+            "Generous-interpretation detection; evasive-answer detection; "
+            "judging whether a flagged downgrade is a genuine softening or "
+            "the teller's own word choice."
+        ),
+    },
+}
+
+
+def discipline_name(n: int) -> str:
+    """Short name for discipline n (1-5)."""
+    if n not in DISCIPLINES:
+        raise ValueError(f"Unknown discipline: {n!r}. Valid: 1-5.")
+    return DISCIPLINES[n]["name"]