pressit 1.0.0__tar.gz

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

pressit-1.0.0/PKG-INFO

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

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

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pressit"
+version = "1.0.0"
+description = "Structured adversarial interrogation of contradictory or uncertain fields (IFS: Iterative Field Synthesis)"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Ryan Wesley Hitchcock" }]
+keywords = ["interrogation", "adversarial-reasoning", "evidence", "red-teaming", "decision-analysis"]
+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"]

pressit-1.0.0/setup.cfg

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

pressit-1.0.0/src/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-1.0.0/src/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}