pressit 1.0.0__py3-none-any.whl

pressit/__init__.py

@@ -0,0 +1,40 @@
+"""pressit — front-facing conversion of the IFS interrogation engine.
+
+IFS = Iterative Field Synthesis: structured adversarial interrogation of
+contradictory or uncertain fields. See README.md for the plain-language
+version. See CHANGELOG.md for what was decoupled from the original skill.
+"""
+
+from . import artifact, backends, engine, evidence, overlay, protocol
+from .artifact import (
+    StateArtifact, Take, Collision, Synthesis, PriorKeyEvaluation,
+    slugify_field, render, render_frontmatter, check_sections, load_prior,
+)
+from .backends import StubBackend, OpenRouterBackend, OllamaBackend
+from .engine import LLMBackend, RunResult, build_user_message, parse_model_json, normalize, run
+from .evidence import EvidenceItem, TAXONOMY, normalize_tag, EvidenceError
+from .overlay import (
+    ProbeBrief, JargonFlag, ground, probe_jargon, handoff_seeds,
+    H_OBFUSCATION, H_GENUINE, H_BOTH, H_INSUFFICIENT,
+)
+from .protocol import (
+    SYSTEM_PROMPT, FieldInput, KeyDraft, ProtocolError,
+    required_collision_pairs, validate_keys,
+    STANDARD, SYSTEMIC, STRESS_TEST, ADJUDICATION,
+)
+
+__version__ = "1.0.0"
+__all__ = [
+    "artifact", "backends", "engine", "evidence", "overlay", "protocol",
+    "StateArtifact", "Take", "Collision", "Synthesis", "PriorKeyEvaluation",
+    "slugify_field", "render", "render_frontmatter", "check_sections", "load_prior",
+    "StubBackend", "OpenRouterBackend", "OllamaBackend",
+    "LLMBackend", "RunResult", "build_user_message", "parse_model_json",
+    "normalize", "run",
+    "EvidenceItem", "TAXONOMY", "normalize_tag", "EvidenceError",
+    "ProbeBrief", "JargonFlag", "ground", "probe_jargon", "handoff_seeds",
+    "H_OBFUSCATION", "H_GENUINE", "H_BOTH", "H_INSUFFICIENT",
+    "SYSTEM_PROMPT", "FieldInput", "KeyDraft", "ProtocolError",
+    "required_collision_pairs", "validate_keys",
+    "STANDARD", "SYSTEMIC", "STRESS_TEST", "ADJUDICATION",
+]

pressit/artifact.py

@@ -0,0 +1,248 @@
+"""The state artifact: the portable, self-contained deliverable of an
+interrogation.
+
+One field, one canonical current state file, named
+``interrogation-state-[field-slug].md``. Another person (or model) must be
+able to continue the investigation from the artifact alone — never
+"see above", never "as discussed", never unstated context, never memory.
+
+Persistence boundary: the engine's responsibility ends when the complete
+artifact has been emitted. The *caller* saves it to disk and supplies it to
+future interrogations. The engine never writes files and never claims
+external persistence occurred.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from .protocol import (
+    KEY_CLASSIFICATIONS, CONFIDENCES, PRIOR_DISPOSITIONS,
+    SESSION_LIFECYCLES, PROTOCOL_NAME, PROTOCOL_VERSION,
+    required_collision_pairs, validate_keys, KeyDraft,
+)
+
+SCHEMA_SECTIONS = (
+    "Interrogation Metadata", "Prior State", "1. Identify", "2. Decompose",
+    "3. Diverge", "4. Collide", "5. Refine", "6. Surprise",
+    "7. Synthesize", "State Status",
+)
+
+
+class ArtifactError(ValueError):
+    """Raised when an artifact breaks the canonical schema."""
+
+
+@dataclass
+class PriorKeyEvaluation:
+    statement: str
+    status: str  # HELD | CRACKED | MODIFIED | SUPERSEDED | UNRESOLVED
+    note: str
+
+    def __post_init__(self) -> None:
+        status = self.status.strip().upper()
+        if status not in PRIOR_DISPOSITIONS:
+            raise ArtifactError(f"Bad prior-Key disposition: {self.status!r}.")
+        self.status = status
+
+
+@dataclass
+class Take:
+    id: str
+    title: str
+    argument: str
+
+
+@dataclass
+class Collision:
+    pair: str
+    contradiction: str
+    premise_failure: str
+    discriminator: str
+
+
+@dataclass
+class Synthesis:
+    established_ground: str
+    surviving_model: str
+    remaining_uncertainties: str
+    primary_next_target: str
+
+
+@dataclass
+class StateArtifact:
+    """A complete, validated interrogation state."""
+
+    field: str
+    session: int
+    date: str  # YYYY-MM-DD
+    depth: str  # one-pass | deep
+    trigger_context: str
+    lifecycle: str  # INITIAL | ITERATIVE | FINAL
+    prior_interrogation: int | None
+    prior_date: str | None
+    prior_keys: list[PriorKeyEvaluation]
+    takes: list[Take]
+    collisions: list[Collision]
+    keys: list[KeyDraft]
+    surprise: str | None
+    synthesis: Synthesis
+    evidence_summary: str = ""
+    interrogation: int = 1
+
+    def __post_init__(self) -> None:
+        if self.session < 1:
+            raise ArtifactError("Session number must be >= 1.")
+        if self.lifecycle not in SESSION_LIFECYCLES:
+            raise ArtifactError(f"Bad lifecycle: {self.lifecycle!r}.")
+        pairs = required_collision_pairs([t.id for t in self.takes])
+        got = [c.pair for c in self.collisions]
+        if got != pairs:
+            raise ArtifactError(
+                f"Collision pairs must be exactly {pairs}, got {got}."
+            )
+        validate_keys(self.keys)
+
+    @property
+    def slug(self) -> str:
+        return slugify_field(self.field)
+
+    @property
+    def filename(self) -> str:
+        return f"interrogation-state-{self.slug}.md"
+
+
+def slugify_field(name: str) -> str:
+    slug = name.lower()
+    slug = re.sub(r"['\"]", "", slug)
+    slug = re.sub(r"[^a-z0-9]+", "-", slug)
+    slug = slug.strip("-")[:64].strip("-")
+    return slug or "field"
+
+
+def render_frontmatter(a: StateArtifact) -> str:
+    return (
+        "---\n"
+        "artifact: interrogation-state\n"
+        f"field: {a.slug}\n"
+        f"interrogation: {a.interrogation}\n"
+        f"date: {a.date}\n"
+        f"depth: {a.depth}\n"
+        f"trigger_context: {a.trigger_context}\n"
+        "status: complete\n"
+        f"lifecycle: {a.lifecycle}\n"
+        f"protocol: {PROTOCOL_NAME}/{PROTOCOL_VERSION}\n"
+        "persistence: external\n"
+        "canonical: true\n"
+        "---"
+    )
+
+
+def render(a: StateArtifact) -> str:
+    """Render the full canonical Markdown artifact."""
+    a.__post_init__()  # re-validate before emission
+    fm = render_frontmatter(a)
+
+    prior_lines = [
+        f"- Prior interrogation: {a.prior_interrogation if a.prior_interrogation else 'Not supplied'}",
+        f"- Prior date: {a.prior_date or '—'}",
+    ]
+    if a.prior_keys:
+        prior_lines.append("- Key dispositions:")
+        for k in a.prior_keys:
+            prior_lines.append(f"  - {k.status}: {k.statement} — {k.note}")
+    else:
+        prior_lines.append("- Key dispositions: none (session 1)")
+
+    take_lines = []
+    for t in a.takes:
+        take_lines.append(f"### Take {t.id} — {t.title}\n\n{t.argument}")
+
+    collision_lines = []
+    for c in a.collisions:
+        collision_lines.append(
+            f"### Pair {c.pair}\n\n"
+            f"- Contradiction: {c.contradiction}\n"
+            f"- Premise that must break: {c.premise_failure}\n"
+            f"- Discriminator: {c.discriminator}"
+        )
+
+    key_lines = []
+    for i, k in enumerate(a.keys, 1):
+        key_lines.append(
+            f"### Key {i}\n\n"
+            f"- Statement: {k.statement}\n"
+            f"- Classification: {k.classification}\n"
+            f"- Evidence: {k.evidence}\n"
+            f"- Confidence: {k.confidence}\n"
+            f"- Structural vulnerability: {k.vulnerability}\n"
+            f"- Falsifier: {k.falsifier}"
+        )
+
+    body = "\n\n".join([
+        fm,
+        f"# Interrogation State: {a.field}",
+        "## Interrogation Metadata\n"
+        f"- Date: {a.date}\n"
+        f"- Field: {a.field}\n"
+        f"- Depth: {a.depth}\n"
+        f"- Interrogation: {a.interrogation}\n"
+        f"- Trigger context: {a.trigger_context}\n"
+        f"- Protocol: {PROTOCOL_NAME}/{PROTOCOL_VERSION}\n"
+        f"- Lifecycle: {a.lifecycle}",
+        "## Prior State\n" + "\n".join(prior_lines),
+        f"## 1. Identify\n- Field: {a.field}\n- Trigger: {a.trigger_context}",
+        f"## 2. Decompose\n{a.evidence_summary or '(evidence logged with the interrogation)'}",
+        "## 3. Diverge\n\n" + "\n\n".join(take_lines),
+        "## 4. Collide\n\n" + "\n\n".join(collision_lines),
+        "## 5. Refine\n\n" + "\n\n".join(key_lines),
+        "## 6. Surprise\n\n" + (a.surprise or "No material Surprise identified."),
+        "## 7. Synthesize\n"
+        f"- Established: {a.synthesis.established_ground}\n"
+        f"- Surviving model: {a.synthesis.surviving_model}\n"
+        f"- Remaining uncertainties: {a.synthesis.remaining_uncertainties}\n"
+        f"- Primary next target: {a.synthesis.primary_next_target}",
+        "## State Status\n"
+        f"- Interrogation: Complete\n"
+        f"- Lifecycle: {a.lifecycle}\n"
+        f"- State: Canonical\n"
+        f"- Persistence: External\n"
+        "- External save: performed by the caller, not the engine",
+    ])
+    return body + "\n"
+
+
+def check_sections(markdown: str) -> list[str]:
+    """Return any canonical schema sections missing from rendered Markdown."""
+    return [s for s in SCHEMA_SECTIONS if f"## {s}" not in markdown]
+
+
+@dataclass
+class PriorState:
+    """A loaded prior artifact for stress-testing in session 2+."""
+
+    artifact: StateArtifact
+
+    def dispositions(self) -> list[PriorKeyEvaluation]:
+        return self.artifact.prior_keys
+
+    def next_session(self) -> int:
+        return self.artifact.interrogation + 1
+
+
+def load_prior(markdown: str) -> dict:
+    """Extract the prior Keys and session number from a saved artifact.
+
+    Returns {'interrogation': int, 'keys': [statements...]}. The engine uses
+    this to stress-test each prior Key and assign dispositions — it never
+    inherits a prior conclusion as established.
+    """
+    keys: list[str] = []
+    for m in re.finditer(r"- Statement:\s*(.+)", markdown):
+        keys.append(m.group(1).strip())
+    session = 1
+    m = re.search(r"^interrogation:\s*(\d+)", markdown, re.M)
+    if m:
+        session = int(m.group(1))
+    return {"interrogation": session, "keys": keys}

pressit/backends.py

@@ -0,0 +1,113 @@
+"""Swappable LLM backends for the engine.
+
+- StubBackend: deterministic canned JSON for tests and demos. No network.
+- OpenRouterBackend: OpenRouter chat completions (documented endpoint
+  https://openrouter.ai/api/v1/chat/completions). Key comes from the
+  OPENROUTER_API_KEY environment variable at call time — never stored in
+  files, never logged. Free-tier friendly.
+- OllamaBackend: a local Ollama server (default http://localhost:11434),
+  for fully offline runs on Ryan-style local setups.
+
+Only the backend you choose is used. No credentials are exchanged in chat
+or files.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.request
+
+
+class StubBackend:
+    """Deterministic backend for tests and offline demos."""
+
+    name = "stub"
+
+    def __init__(self, artifact_json: dict) -> None:
+        self._artifact_json = artifact_json
+
+    def complete(self, system: str, user: str) -> str:
+        return json.dumps(self._artifact_json)
+
+
+class OpenRouterBackend:
+    """OpenRouter chat completions backend.
+
+    Reads OPENROUTER_API_KEY from the environment at call time. Optional
+    OPENROUTER_MODEL selects the model (defaults to a free-tier model).
+    """
+
+    name = "openrouter"
+    ENDPOINT = "https://openrouter.ai/api/v1/chat/completions"
+
+    def __init__(self, model: str | None = None, endpoint: str | None = None) -> None:
+        self.model = model or os.environ.get("OPENROUTER_MODEL", "")
+        self.endpoint = endpoint or os.environ.get("OPENROUTER_ENDPOINT") or self.ENDPOINT
+        if not self.model:
+            raise RuntimeError(
+                "No model selected: pass model= or set OPENROUTER_MODEL."
+            )
+
+    def complete(self, system: str, user: str) -> str:
+        key = os.environ.get("OPENROUTER_API_KEY")
+        if not key:
+            raise RuntimeError(
+                "OPENROUTER_API_KEY is not set. Export it before running."
+            )
+        payload = json.dumps({
+            "model": self.model,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": user},
+            ],
+            "temperature": 0.2,
+            "response_format": {"type": "json_object"},
+        }).encode()
+        req = urllib.request.Request(
+            self.endpoint, data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {key}",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=120) as resp:
+                body = json.loads(resp.read().decode())
+        except Exception as exc:
+            raise RuntimeError(f"OpenRouter request failed: {exc}") from exc
+        try:
+            return body["choices"][0]["message"]["content"]
+        except (KeyError, IndexError) as exc:
+            raise RuntimeError(f"Unexpected OpenRouter response shape: {body!r}") from exc
+
+
+class OllamaBackend:
+    """Local Ollama backend (http://localhost:11434 by default)."""
+
+    name = "ollama"
+
+    def __init__(self, model: str = "llama3.1",
+                 base_url: str = "http://localhost:11434") -> None:
+        self.model = model
+        self.base_url = base_url.rstrip("/")
+
+    def complete(self, system: str, user: str) -> str:
+        payload = json.dumps({
+            "model": self.model,
+            "system": system,
+            "prompt": user,
+            "stream": False,
+            "format": "json",
+            "options": {"temperature": 0.2},
+        }).encode()
+        req = urllib.request.Request(
+            f"{self.base_url}/api/generate", data=payload,
+            headers={"Content-Type": "application/json"},
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=300) as resp:
+                body = json.loads(resp.read().decode())
+        except Exception as exc:
+            raise RuntimeError(f"Ollama request failed: {exc}") from exc
+        return body.get("response", "")

pressit/engine.py

@@ -0,0 +1,142 @@
+"""Engine: LLM backend interface and the interrogation runner.
+
+The runner is provider-agnostic: any model that can follow the protocol
+prompt works. Backends are swappable — see backends.py. The runner:
+
+1. Builds the user message from the field, overlay flag, and prior artifact.
+2. Calls the backend.
+3. Parses the model's JSON (fences tolerated).
+4. Normalizes: takes filtered to A/B/C, collisions restricted to required
+   pairs, keys capped at 5, probe dropped when the overlay is off.
+5. Returns a normalized artifact dict the caller can render with
+   artifact.render().
+
+No network happens here; the backend decides how the call is made.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Protocol, runtime_checkable
+
+from .protocol import SYSTEM_PROMPT, FieldInput, required_collision_pairs
+
+
+class EngineError(RuntimeError):
+    """The model call failed or returned an unreadable artifact."""
+
+
+@runtime_checkable
+class LLMBackend(Protocol):
+    """Anything that can take (system, user) and return raw model text."""
+
+    name: str
+
+    def complete(self, system: str, user: str) -> str: ...
+
+
+def build_user_message(field_text: str, *, overlay: bool,
+                       prior_json: str | None) -> str:
+    parts = [f"OVERLAY: {'ON' if overlay else 'OFF'}"]
+    if prior_json:
+        parts.append(
+            "PRIOR ARTIFACT (test these Keys, do not inherit Takes as authority):\n"
+            + prior_json
+        )
+    else:
+        parts.append("PRIOR ARTIFACT: none")
+    parts.append(f"FIELD:\n{field_text}")
+    return "\n\n".join(parts)
+
+
+def parse_model_json(raw: str) -> dict:
+    """Extract the JSON object from model output; fences tolerated."""
+    text = raw.strip()
+    fenced = text.split("```")
+    body = fenced[1] if len(fenced) >= 3 else text
+    start = body.find("{")
+    end = body.rfind("}")
+    if start < 0 or end <= start:
+        raise EngineError(
+            "The engine did not return a state artifact. "
+            "Try a tighter field or a larger model."
+        )
+    try:
+        return json.loads(body[start: end + 1])
+    except json.JSONDecodeError as exc:
+        raise EngineError(f"The engine returned unreadable JSON: {exc}") from exc
+
+
+def normalize(field_text: str, *, overlay: bool, prior_session: int | None,
+              model: dict) -> dict:
+    """Normalize raw model output into a validated artifact dict.
+
+    Enforces the hard limits in code: valid Take ids, required collision
+    pairs only, at most 5 Keys, probe dropped unless the overlay is on.
+    """
+    takes = [t for t in model.get("takes", []) if t.get("id") in ("A", "B", "C")]
+    if len(takes) < 2:
+        raise EngineError(
+            f"The engine returned {len(takes)} valid Takes; the protocol requires 2-3."
+        )
+    pairs = required_collision_pairs([t["id"] for t in takes])
+    collisions = [c for c in model.get("collisions", []) if c.get("pair") in pairs]
+    keys = model.get("keys", [])
+    if len(keys) > 5:
+        keys = keys[:5]
+    if len(keys) < 3:
+        raise EngineError(
+            f"The engine returned only {len(keys)} Keys; the protocol requires 3-5."
+        )
+    meta = model.get("meta", {})
+    probe = model.get("probe") if overlay else None
+
+    session = (prior_session + 1) if prior_session is not None else 1
+    return {
+        "meta": {
+            "field": meta.get("field") or field_text[:80],
+            "status": meta.get("status") or ("ITERATIVE" if prior_session else "INITIAL"),
+            "session": session,
+        },
+        "field": model.get("field", {"objective": "", "scope": ""}),
+        "priorState": model.get("priorState", {"reference": None, "evaluations": []}),
+        "evidence": model.get("evidence", {"facts": [], "claims": [], "unknowns": []}),
+        "probe": probe,
+        "takes": takes,
+        "collisions": collisions,
+        "keys": keys,
+        "surprise": model.get("surprise"),
+        "synthesis": model.get("synthesis", {}),
+        "overlay": overlay,
+    }
+
+
+@dataclass
+class RunResult:
+    ok: bool
+    artifact: dict | None = None
+    error: str | None = None
+
+
+def run(field_input: FieldInput, backend: LLMBackend,
+        *, prior_json: str | None = None,
+        prior_session: int | None = None) -> RunResult:
+    """Run one interrogation against a backend. One pass, never loops."""
+    FieldInput(
+        field=field_input.field, mode=field_input.mode,
+        overlay=field_input.overlay, evidence=field_input.evidence,
+    )  # re-validate
+    user = build_user_message(field_input.field, overlay=field_input.overlay,
+                              prior_json=prior_json)
+    try:
+        raw = backend.complete(SYSTEM_PROMPT, user)
+    except Exception as exc:  # backend errors surface as engine errors
+        return RunResult(ok=False, error=f"Backend {backend.name} failed: {exc}")
+    try:
+        model = parse_model_json(raw)
+        artifact = normalize(field_input.field, overlay=field_input.overlay,
+                             prior_session=prior_session, model=model)
+    except EngineError as exc:
+        return RunResult(ok=False, error=str(exc))
+    return RunResult(ok=True, artifact=artifact)

pressit/evidence.py

@@ -0,0 +1,89 @@
+"""Evidence taxonomy.
+
+Every input to an interrogation is tagged with exactly one of these tiers.
+The core rule is negative: never silently upgrade an assertion into a fact
+or an inference into a conclusion. Tags stay visible through every phase.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# --- Tier definitions -------------------------------------------------------
+
+FACT = "FACT"
+OBSERVATION = "OBSERVATION"
+CLAIM = "CLAIM"
+INFERENCE = "INFERENCE"
+ASSUMPTION = "ASSUMPTION"
+HYPOTHESIS = "HYPOTHESIS"
+REQUIREMENT = "REQUIREMENT"
+CONSTRAINT = "CONSTRAINT"
+DEPENDENCY = "DEPENDENCY"
+UNKNOWN = "UNKNOWN"
+# Overlay-only: set when the optional evasion-probe overlay is ON.
+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: (
+        "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 interrogation."""
+
+    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, *, overlay_on: bool = False) -> str:
+    """Validate and normalize a tag. OBFUSCATION needs the overlay on."""
+    normalized = tag.strip().upper()
+    if normalized not in TAXONOMY:
+        raise EvidenceError(f"Unknown evidence tag {tag!r}.")
+    if normalized == OBFUSCATION and not overlay_on:
+        raise EvidenceError(
+            "OBFUSCATION is overlay-only: it may be tagged only when the "
+            "evasion-probe overlay is active. Use CLAIM with a hypothesis "
+            "marker for suspected-but-untested evasion."
+        )
+    return normalized
+
+
+def tag_list() -> list[str]:
+    """All valid tags, in canonical order."""
+    return list(TAXONOMY)

pressit/overlay.py

@@ -0,0 +1,135 @@
+"""The evasion-probe overlay (opt-in).
+
+Decoupling note: this is the mechanism of the skill-suite's "Field Forge"
+overlay, renamed in plain language. The workshop stage names
+(Anvil/Hammer/Furnace) are replaced by what each stage actually does:
+
+- GROUND (was "Anvil"): map the exact situational state without forcing a
+  narrative resolution.
+- PROBE (was "Hammer"): test — never presume — evasion hypotheses, including
+  jargon armor of any kind (corporate, legal, therapeutic, wellness).
+- HANDOFF (was "Furnace"): build 2-3 Take seeds and feed them into the
+  kernel's Diverge phase, then stand down.
+
+The overlay never replaces Diverge/Collide. Default: OFF. Activate only when
+asked, or when the field is clearly an evasion / responsibility problem.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+GROUND = "ground"
+PROBE = "probe"
+HANDOFF = "handoff"
+
+# Evasion hypotheses for jargon-armor testing. Every flagged instance of
+# shield-vocabulary is run through H-obfuscation / H-genuine / H-both —
+# never pre-judged as armor by category membership alone.
+H_OBFUSCATION = "H-obfuscation"
+H_GENUINE = "H-genuine"
+H_BOTH = "H-both"
+H_INSUFFICIENT = "insufficient-evidence"
+
+JARGON_HYPOTHESES = (H_OBFUSCATION, H_GENUINE, H_BOTH, H_INSUFFICIENT)
+
+SUPPORT_STATUSES = ("supported", "contested", "unsupported")
+
+
+class OverlayError(ValueError):
+    """Raised when overlay input breaks the contract."""
+
+
+@dataclass
+class JargonFlag:
+    """One instance of possibly-evasive vocabulary."""
+
+    phrase: str
+    hypothesis: str = H_INSUFFICIENT
+    discriminating_evidence: str = ""
+
+    def __post_init__(self) -> None:
+        if self.hypothesis not in JARGON_HYPOTHESES:
+            raise OverlayError(f"Bad jargon hypothesis: {self.hypothesis!r}.")
+        if not self.phrase.strip():
+            raise OverlayError("Jargon flag needs the flagged phrase.")
+
+
+@dataclass
+class ProbeBrief:
+    """The overlay's output: audited ground, tested hypotheses, Take seeds.
+
+    This is a *brief*, not an interrogation result — it is fed into the
+    kernel's Diverge phase. The kernel's state artifact stays canonical.
+    """
+
+    field: str
+    held_tensions: list[str] = field(default_factory=list)
+    person_state_sequence: list[str] = field(default_factory=list)
+    corrections: list[str] = field(default_factory=list)
+    obfuscated_object: str = ""
+    obfuscation_support: str = H_INSUFFICIENT
+    apparent_function: str = ""
+    active_tactics: list[str] = field(default_factory=list)
+    jargon_flags: list[JargonFlag] = field(default_factory=list)
+    take_seeds: list[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        if not self.field.strip():
+            raise OverlayError("Probe brief needs a field name.")
+        if self.obfuscation_support not in SUPPORT_STATUSES + (H_INSUFFICIENT,):
+            raise OverlayError(f"Bad support status: {self.obfuscation_support!r}.")
+
+    def supported_obfuscation(self) -> bool:
+        """True only when the evasion hypothesis has discriminating evidence.
+
+        The OBFUSCATION evidence tag may be used only in this case; anything
+        else stays CLAIM with a hypothesis marker.
+        """
+        return self.obfuscation_support == "supported" and bool(
+            self.obfuscated_object.strip()
+        )
+
+
+def ground(held_tensions: list[str], person_states: list[str]) -> dict:
+    """GROUND stage: hold contradictions live, time-index person states.
+
+    Contradictions are stated as parallel non-subordinating sentences:
+    "X is true. Y is also true." Never "X, but Y".
+    """
+    for t in held_tensions:
+        if not t.strip():
+            raise OverlayError("Held tension must not be empty.")
+    return {"held_tensions": held_tensions, "person_state_sequence": person_states}
+
+
+def probe_jargon(phrase: str, evidence_for_obfuscation: str,
+                 evidence_for_genuine: str) -> JargonFlag:
+    """Run one jargon instance through the hypothesis protocol.
+
+    Both hypotheses are tested against discriminating evidence. When the
+    evidence cannot distinguish them, the honest finding 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:
+        return JargonFlag(phrase, H_OBFUSCATION, evidence_for_obfuscation)
+    if has_gen and not has_obf:
+        return JargonFlag(phrase, H_GENUINE, evidence_for_genuine)
+    if has_obf and has_gen:
+        return JargonFlag(
+            phrase, H_BOTH,
+            f"for obfuscation: {evidence_for_obfuscation}; "
+            f"for genuine: {evidence_for_genuine}",
+        )
+    return JargonFlag(phrase, H_INSUFFICIENT, "no discriminating evidence yet")
+
+
+def handoff_seeds(brief: ProbeBrief) -> list[str]:
+    """HANDOFF stage: 2-3 Take seeds for the kernel's Diverge phase."""
+    if not (2 <= len(brief.take_seeds) <= 3):
+        raise OverlayError(
+            f"Handoff must produce 2-3 Take seeds, got {len(brief.take_seeds)}."
+        )
+    return list(brief.take_seeds)

pressit/protocol.py

@@ -0,0 +1,252 @@
+"""The IFS interrogation protocol: phases, modes, collision rules, and the
+prompt text that drives an LLM backend.
+
+IFS = Iterative Field Synthesis. A *field* is any question, claim, or
+contradiction you want to pressure-test. The engine's core invariant:
+**confidence and correctness are independent variables** — interrogate the
+gap between them.
+
+Not related to Internal Family Systems therapy; the acronym collision is
+coincidental and noted once here.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .evidence import EvidenceItem, normalize_tag
+
+# --- Constants ---------------------------------------------------------------
+
+PROTOCOL_NAME = "IFS"
+PROTOCOL_VERSION = "1.0"
+PROTOCOL_LINEAGE = (
+    "Front-facing conversion of the ifs-interrogation skill v2.0 (Ryan's "
+    "skill-suite, MIT). Mechanism preserved; original naming decoupled."
+)
+
+MIN_KEYS = 3
+MAX_KEYS = 5
+MIN_TAKES = 2
+MAX_TAKES = 3
+TAKE_IDS = ("A", "B", "C")
+
+KEY_CLASSIFICATIONS = (
+    "ESTABLISHED",
+    "STRONGLY INFERRED",
+    "PLAUSIBLE",
+    "SPECULATIVE",
+    "UNRESOLVED",
+)
+
+CONFIDENCES = ("HIGH", "MODERATE", "LOW")
+
+PRIOR_DISPOSITIONS = ("HELD", "CRACKED", "MODIFIED", "SUPERSEDED", "UNRESOLVED")
+
+SESSION_LIFECYCLES = ("INITIAL", "ITERATIVE", "FINAL")
+
+# --- Modes --------------------------------------------------------------------
+
+STANDARD = "standard"        # one-pass, five phases (default)
+SYSTEMIC = "systemic"        # deep nine-stage run + meta-cycle
+STRESS_TEST = "stress-test"  # session 2+: test prior Keys against new evidence
+ADJUDICATION = "adjudication"  # judge a claim against a framework's standards
+
+MODES = {
+    STANDARD: "Bounded fields: decisions, claims, single contradictions. One pass.",
+    SYSTEMIC: "Structural or multi-actor fields, recurring patterns. Nine stages, may iterate.",
+    STRESS_TEST: "Prior state exists. Every prior Key is dispositioned; only new Keys are added.",
+    ADJUDICATION: "A claim is judged against an explicit standard — full deep run, no compression.",
+}
+
+
+@dataclass(frozen=True)
+class Phase:
+    id: str
+    name: str
+    brief: str
+
+
+ONE_PASS_PHASES: tuple[Phase, ...] = (
+    Phase("identify", "Identify & Decompose",
+          "Bound the field. Name the objective and scope. Tag every input. Do not upgrade evidence."),
+    Phase("diverge", "Diverge",
+          "Two Takes by default. A third Take only if a genuinely independent model exists. "
+          "Each Take is internally coherent, uses tagged evidence, makes its strongest case — no strawmen, no premature consensus."),
+    Phase("collide", "Collide",
+          "Force Takes into conflict: required pairs only. Each collision names the contradiction, "
+          "the premise that must break, and the discriminator evidence. Collision must hurt brittle claims."),
+    Phase("refine", "Refine",
+          f"Skeptic pass, then extract {MIN_KEYS}-{MAX_KEYS} load-bearing Keys. Prefer fewer, stronger. "
+          "A Key that cannot survive stress-testing is discarded, not softened."),
+    Phase("capture", "Surprise + Synthesis + Capture",
+          "Surprise must emerge from collision, not from a single Take. "
+          "Then the surviving model, and the complete portable state artifact."),
+)
+
+DEEP_STAGES: tuple[Phase, ...] = (
+    Phase("identify", "Identify", "Bound the field, objective, scope."),
+    Phase("decompose", "Decompose", "Tag every input; name actors, temporal structure, existing contradictions."),
+    Phase("question", "Question", "Identify questions capable of materially changing the model. "
+          "For each: what is unknown, why it matters, which interpretations it affects, "
+          "what evidence would resolve it, what happens if YES / if NO."),
+    Phase("test", "Test", "Attempt to break the strongest interpretations. "
+          "Actively search for evidence that would make the favored explanation wrong. "
+          "Do not protect a preferred conclusion."),
+    Phase("collide", "Collide", "Force Takes into conflict; name contradictions, broken premises, discriminators."),
+    Phase("refine", "Refine", "Extract 3-5 load-bearing Keys; discard what cannot survive."),
+    Phase("surprise", "Surprise", "What is now visible that wasn't before? Force it."),
+    Phase("synthesize", "Synthesize", "Established / inferred / rejected / unresolved. The strongest surviving explanation."),
+    Phase("capture", "Capture State", "Emit the complete self-contained state artifact."),
+)
+
+META_CYCLE = (
+    "Gather the field", "Map relationships", "Locate tensions & harmonies",
+    "Extract recurring structures", "Generate explanatory Keys",
+    "Stress-test Keys", "Update the field", "Iterate or capture",
+)
+
+# --- Collision rules -----------------------------------------------------------
+
+def required_collision_pairs(take_ids: list[str]) -> list[str]:
+    """Required collision pairs given the number of Takes.
+
+    Two Takes -> one pair (A/B). Three Takes -> all three pairs (A/B, A/C, B/C).
+    No extra collisions are ever added.
+    """
+    ids = [t.strip().upper() for t in take_ids]
+    if not (MIN_TAKES <= len(ids) <= MAX_TAKES):
+        raise ValueError(f"Takes must be {MIN_TAKES}-{MAX_TAKES}, got {len(ids)}.")
+    if ids != list(TAKE_IDS[: len(ids)]):
+        raise ValueError(f"Take ids must be A..B or A..C in order, got {ids}.")
+    pairs = ["A/B"]
+    if len(ids) == MAX_TAKES:
+        pairs += ["A/C", "B/C"]
+    return pairs
+
+
+class ProtocolError(ValueError):
+    """Raised when interrogation input breaks protocol rules."""
+
+
+@dataclass
+class KeyDraft:
+    """A refined Key before validation: statement, classification, evidence,
+    confidence, structural vulnerability, falsifier."""
+
+    statement: str
+    classification: str
+    evidence: str
+    confidence: str
+    vulnerability: str
+    falsifier: str
+
+
+def validate_keys(keys: list[KeyDraft]) -> list[KeyDraft]:
+    """Enforce the Key contract: 3-5 Keys, every component present and valid."""
+    if not (MIN_KEYS <= len(keys) <= MAX_KEYS):
+        raise ProtocolError(
+            f"Interrogations must extract {MIN_KEYS}-{MAX_KEYS} Keys, got {len(keys)}. "
+            "Prefer fewer, stronger — do not pad to reach the minimum."
+        )
+    for key in keys:
+        classification = key.classification.strip().upper()
+        if classification not in KEY_CLASSIFICATIONS:
+            raise ProtocolError(f"Bad Key classification: {key.classification!r}.")
+        confidence = key.confidence.strip().upper()
+        if confidence not in CONFIDENCES:
+            raise ProtocolError(f"Bad Key confidence: {key.confidence!r}.")
+        for part, name in (
+            (key.statement, "statement"),
+            (key.evidence, "evidence"),
+            (key.vulnerability, "vulnerability"),
+            (key.falsifier, "falsifier"),
+        ):
+            if not part.strip():
+                raise ProtocolError(f"Key is missing its {name}: {key.statement[:60]!r}.")
+    return keys
+
+
+@dataclass
+class FieldInput:
+    """Everything the engine needs for one interrogation."""
+
+    field: str
+    mode: str = STANDARD
+    overlay: bool = False
+    evidence: list[EvidenceItem] = field(default_factory=list)
+    prior_artifact_path: str | None = None
+
+    def __post_init__(self) -> None:
+        if not self.field.strip():
+            raise ProtocolError("Field must not be empty.")
+        if self.mode not in MODES:
+            raise ProtocolError(f"Unknown mode {self.mode!r}. Valid: {', '.join(MODES)}.")
+        for item in self.evidence:
+            normalize_tag(item.tag, overlay_on=self.overlay)
+
+
+# --- System prompt (drives any LLM backend) -------------------------------------
+
+SYSTEM_PROMPT = """You are IFS v1.0 (Iterative Field Synthesis), a provider-agnostic one-pass interrogation engine.
+
+CORE PRINCIPLE
+Confidence and correctness are independent variables. Interrogate the gap between them.
+
+EVIDENCE DISCIPLINE (never silently upgrade)
+FACT — directly established
+OBSERVATION — reported/logged, unverified
+CLAIM — actor/source assertion
+INFERENCE — logical conclusion
+ASSUMPTION — unsupported presumption
+HYPOTHESIS — proposed explanation
+REQUIREMENT — condition a model needs
+CONSTRAINT — limiting boundary
+DEPENDENCY — state-dependent element
+UNKNOWN — presently undetermined critical variable
+OBFUSCATION — only if the evasion-probe overlay is ON: evasive maneuver masking responsibility
+
+Never fabricate actors, facts, motives, events, or certainty.
+
+ENGINE (run internally, one pass, no looping)
+1. IDENTIFY & DECOMPOSE — name the field, objective, scope. Tag every input.
+2. DIVERGE — 2 Takes by default; Take C only if a genuinely independent third model exists. Each Take uses tagged evidence, is internally coherent, makes its strongest case, avoids strawmen and premature consensus.
+3. COLLIDE — required pairs only (A/B; A/C and B/C iff C exists). Never add extra collisions. Each collision: contradiction, premise that must break, discriminator evidence.
+4. REFINE — 3-5 load-bearing Keys. Prefer fewer, stronger. Each Key: statement, classification (ESTABLISHED | STRONGLY INFERRED | PLAUSIBLE | SPECULATIVE | UNRESOLVED), evidence with tags, confidence (HIGH | MODERATE | LOW), structural vulnerability, falsifier.
+5. SURPRISE + SYNTHESIS + CAPTURE — Surprise must emerge from collision, not from a single Take. If none: surprise = null. Synthesis: established ground, surviving model, remaining uncertainties, primary next target.
+
+PRIOR STATE
+If a prior artifact is supplied: test every prior Key. Mark HELD | CRACKED | MODIFIED | SUPERSEDED | UNRESOLVED. Add only genuinely new Keys. Session number = prior + 1. Status ITERATIVE (FINAL only if the field is resolved enough that the next target is idle). Never silently rewrite a prior Key; preserve failures visibly.
+
+LIGHT COMPRESSION
+Cut restated evidence, redundant framing, connective prose. If a sentence can be removed without losing a Key, discriminator, or classification, remove it.
+
+HOLD CONTRADICTIONS LIVE
+State opposing facts in parallel non-subordinating sentences. Do not use "but" / "however" / "which means" to quietly privilege one side.
+
+EVASION-PROBE OVERLAY (only when overlay=true)
+Ground: time-index person-states; classify corrections as Detail-Correction vs Core-Claim.
+Probe: name the obfuscated object (the exact responsibility that may be dodged), apparent function, active tactics, jargon-armor flags. Isolate motive: log observed action and quotes only — never supply unstated motives. Test jargon claims as hypotheses (H-obfuscation / H-genuine / H-both); never pre-judge a category of language as armor.
+Handoff: produce 2-3 Take seeds from the ground and stripped material, labeled as seeds, and feed them into Diverge. Then stand down.
+If overlay is false, omit the probe entirely. Do not hunt for interpersonal evasion in a systems field.
+
+OUTPUT
+Return ONLY a JSON object matching this shape (no markdown fences, no preamble):
+{
+  "meta": { "field": string, "status": "INITIAL"|"ITERATIVE"|"FINAL" },
+  "field": { "objective": string, "scope": string },
+  "priorState": { "reference": string|null, "evaluations": [{ "statement": string, "status": "HELD"|"CRACKED"|"MODIFIED"|"SUPERSEDED"|"UNRESOLVED", "note": string }] },
+  "evidence": {
+    "facts": [{ "text": string, "tag": "FACT"|"OBSERVATION"|"CONSTRAINT"|"REQUIREMENT" }],
+    "claims": [{ "text": string, "tag": "CLAIM"|"OBSERVATION"|"INFERENCE"|"ASSUMPTION"|"HYPOTHESIS"|"OBFUSCATION" }],
+    "unknowns": [{ "text": string, "tag": "UNKNOWN"|"DEPENDENCY"|"ASSUMPTION" }]
+  },
+  "probe": { "obfuscatedObject": string, "apparentFunction": string, "activeTactics": string[], "jargonFlags": string[] } | null,
+  "takes": [{ "id": "A"|"B"|"C", "title": string, "argument": string }],
+  "collisions": [{ "pair": "A/B"|"A/C"|"B/C", "contradiction": string, "premiseFailure": string, "discriminator": string }],
+  "keys": [{ "statement": string, "classification": string, "evidence": string, "confidence": "HIGH"|"MODERATE"|"LOW", "vulnerability": string, "falsifier": string }],
+  "surprise": string | null,
+  "synthesis": { "establishedGround": string, "survivingModel": string, "remainingUncertainties": string, "primaryNextTarget": string }
+}
+
+Hard limits: 2-3 takes, required collisions only, 3-5 keys, no TODOs, no placeholders, no motive attribution without evidence. Unresolved questions go in remainingUncertainties and primaryNextTarget — they do not trigger another pass."""

pressit-1.0.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: pressit
+Version: 1.0.0
+Summary: Structured adversarial interrogation of contradictory or uncertain fields (IFS: Iterative Field Synthesis)
+Author: Ryan Wesley Hitchcock
+License: MIT
+Project-URL: Homepage, https://github.com/ohpersonperson/frontface
+Keywords: interrogation,adversarial-reasoning,evidence,red-teaming,decision-analysis
+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
+
+# IFS — Iterative Field Synthesis
+
+A structured way to pressure-test a claim, decision, or contradiction so it comes out the other side either **load-bearing** or **dead** — with the reasoning preserved in a portable document.
+
+No prerequisites. You don't need to know anything about the project's history, any framework, or any belief system. The mechanism is the whole product.
+
+*(Lineage: this is the front-facing conversion of the `ifs-interrogation` skill from Ryan's skill-suite, MIT. What changed in the conversion is documented in CHANGELOG.md — mechanism kept, original naming removed.)*
+
+## What it does
+
+You hand the engine a **field** — a situation, claim, or contradiction with real stakes and real uncertainty. The engine runs it through a fixed interrogation:
+
+1. **Identify & Decompose** — bound the field, name the objective and scope, tag every input with an evidence tier (FACT, CLAIM, UNKNOWN, …). Evidence is never silently upgraded: a claim stays a claim until it's proven.
+2. **Diverge** — build the 2 or 3 strongest internally-coherent cases (Takes). No strawmen, no premature consensus.
+3. **Collide** — force the Takes into conflict. Every collision names the contradiction, the premise that must break, and the discriminator evidence that decides it. If the collision doesn't hurt brittle claims, it wasn't a real collision.
+4. **Refine** — a skeptic pass, then extract 3–5 **load-bearing Keys**: crisp assertions, each with a classification, the tagged evidence behind it, a confidence level, its structural vulnerability, and its falsifier — the specific evidence that would overturn it. A Key that can't survive is discarded, not softened.
+5. **Surprise + Synthesis + Capture** — the non-obvious result that emerged *from the collision* (not from one Take), the surviving model, and the complete **state artifact**: a self-contained Markdown document another person or model can continue from without any of the original conversation.
+
+Core principle: **confidence and correctness are independent variables.** The engine interrogates the gap between them.
+
+## Why it works
+
+Most reasoning failures aren't stupidity — they're structural. Claims quietly upgrade into facts. The first plausible story wins and alternatives never get built. Contradictions get smoothed over with "however." IFS attacks all three mechanically:
+
+- **Evidence tagging** makes silent upgrades impossible — every input carries its tier through every phase.
+- **Forced Takes** mean the strongest opposing case gets built with the same care as your own.
+- **Named collisions with discriminators** force a decision rule instead of vibes.
+- **Keys carry falsifiers**, so the output tells you exactly what would prove it wrong.
+- **Prior Keys are stress-tested, never inherited.** In session 2+, every old Key gets a verdict — HELD, CRACKED, MODIFIED, SUPERSEDED, UNRESOLVED — and failures stay visible in the artifact instead of being quietly rewritten.
+
+## Quickstart
+
+Zero dependencies beyond Python 3.10+ and a model to run the engine on.
+
+```bash
+cd ifs
+python3 -m unittest discover -s tests     # 41 offline tests — prove the machinery first
+```
+
+To run a real interrogation, you need a backend — any LLM that can follow the protocol prompt:
+
+```bash
+# Fully offline: local Ollama
+python3 examples/run_local.py my-field.txt --ollama
+
+# OpenRouter (free-tier models work fine)
+OPENROUTER_API_KEY=... OPENROUTER_MODEL="nvidia/nemotron-3-ultra-550b-a55b:free" \
+  python3 examples/run_local.py my-field.txt
+
+# Session 2+: feed the prior artifact back in; old Keys get stress-tested
+python3 examples/run_local.py new-evidence.txt --prior interrogation-state-my-field.md --ollama
+```
+
+`my-field.txt` is just prose: the situation, the conflicting accounts, the stakes. The engine returns `interrogation-state-<slug>.md` — the portable artifact.
+
+Or use it as a library:
+
+```python
+from pressit import FieldInput, EvidenceItem, run, OllamaBackend
+
+field = FieldInput(
+    field="Q3 revenue is up 41%. The owner calls it a turnaround. Is it?",
+    evidence=[
+        EvidenceItem("Q3 revenue $48k; Q2 $34k (POS records)", "FACT"),
+        EvidenceItem("A July estate sale moved ~2,100 rare books", "FACT"),
+        EvidenceItem("Owner: 'new regulars are driving it'", "CLAIM"),
+        EvidenceItem("Q4 inventory pipeline", "UNKNOWN"),
+    ],
+)
+result = run(field, OllamaBackend())
+assert result.ok
+print(result.artifact["surprise"])
+```
+
+## The four modes
+
+| Mode | When |
+|---|---|
+| `standard` (default) | Bounded fields: decisions, claims, single contradictions. One pass, never loops. |
+| `systemic` | Structural/multi-actor fields, recurring patterns. Nine stages; may iterate across sessions. |
+| `stress-test` | Prior state exists. Every prior Key is dispositioned; only genuinely new Keys are added. |
+| `adjudication` | A claim is judged against an explicit standard (a contract, a policy, a spec). Full deep run, no compression. |
+
+The optional **evasion-probe overlay** (off by default) handles interpersonal fields where language may be doing evasive work: it maps the observable ground, tests evasion hypotheses (never presumes them — jargon is tested as H-obfuscation / H-genuine / H-both), and feeds Take seeds into Diverge. It never replaces the engine.
+
+## Inputs, outputs
+
+- **Input:** a field description (prose), optional tagged evidence, optional prior artifact, optional overlay.
+- **Output:** a normalized artifact dict, or a rendered `interrogation-state-<slug>.md` — complete, self-contained, no placeholders, no TODOs.
+- **The engine never writes files and never claims external persistence.** Your code saves the artifact; the engine's job ends when it's emitted. That's the persistence boundary, and it's deliberate.
+
+## Worked examples
+
+Three complete runs a stranger can follow, in `examples/`:
+
+1. `example-1-corner-books.md` — standard one-pass: is a bookstore's revenue jump a turnaround or a blip?
+2. `example-2-corner-books-session-2.md` — stress-test mode: new evidence meets old Keys; watch a Key get CRACKED and preserved visibly.
+3. `example-3-sla-adjudication.md` — adjudication mode: a vendor's SLA claim judged against the contract text.
+
+*All three fields are constructed for teaching — they show the engine's shape, not real findings.*
+
+## FAQ
+
+**Is this related to Internal Family Systems therapy?** No. The acronym collision is coincidental; this is an interrogation engine, not a therapeutic method.
+
+**Does it need an internet connection?** Only for the model call, and only the backend you choose. With Ollama it's fully offline. The 41 unit tests never touch the network.
+
+**What does it cost?** The package is free and dependency-free. The model call costs whatever your provider charges — free-tier models work; the engine was evaluated on them.
+
+## License
+
+MIT. See LICENSE.

pressit-1.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+pressit/__init__.py,sha256=mXmDgXCfJjs_RBYPWPASgyeALo8JeeySo67l-SpnpwI,1897
+pressit/artifact.py,sha256=wS806AXRqi_ON2kjQRE-N4EwU3UUXsAGqIUITr64wiQ,7946
+pressit/backends.py,sha256=V1KSIlbzh8ow7gMi4WvUM0-hionE4XfYKhP5Ydl6udk,3981
+pressit/engine.py,sha256=8jtPdwFz84l26E3-n0tWyC7DP9MCDa_27yrp9tjSoCk,5205
+pressit/evidence.py,sha256=4bfTgDLoa5ocoRHCvhimy5LHcM3hZc-hFRHmopsxsN8,3161
+pressit/overlay.py,sha256=h4HaRpirLrFpbb8dhhxqJnKLZbtPsozmIP_YSJdRxWc,5115
+pressit/protocol.py,sha256=qyJH5dYtXNXkTYZUA8BK5ywcFqHQUMc7_pivoUuqVSc,12474
+pressit-1.0.0.dist-info/licenses/LICENSE,sha256=Zx_XafyZDq7qBexUb7tER9kYlBZ0rCVaAwKuqMCfxLE,1078
+pressit-1.0.0.dist-info/METADATA,sha256=-AXDgH9HvcDKIEWNNqtXOK7icos-sVDmvjUDRsKyAv8,7496
+pressit-1.0.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pressit-1.0.0.dist-info/top_level.txt,sha256=zPmo5-EO3gsp9sYNXa4vSJweLWwapVhyKucspMl4PQ8,8
+pressit-1.0.0.dist-info/RECORD,,

pressit-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
+

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

pressit-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pressit