frontface-metacog 1.0.0__tar.gz

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

frontface_metacog-1.0.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: frontface-metacog
+Version: 1.0.0
+Summary: Five-step reasoning pressure test: trigger thresholds, steelman countermodel, load-bearing assumptions, collision, confidence revision
+Author: Ryan Wesley Hitchcock
+License: MIT
+Project-URL: Homepage, https://github.com/ohpersonperson/frontface
+Keywords: reasoning,metacognition,red-teaming,confidence,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
+
+# Confidence Auditor — five-step reasoning pressure test
+
+Interrogation, not supervision. You hand it reasoning-in-progress; it
+returns a **collision record** with a revised confidence — before→after,
+per load-bearing assumption and overall. It never originates analysis.
+It pressure-tests analysis that already exists.
+
+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 `metacog` skill from
+Ryan's skill-suite, MIT. What changed in the conversion is documented in
+CHANGELOG.md — the name and nothing else, really; this was already the
+cleanest skill in the suite.)*
+
+## What it does
+
+Five steps, in order, never reordered — evaluating before colliding is
+the most common failure mode (you polish claims that should have died):
+
+1. **Trigger Thresholds** — decide whether it's worth firing at all.
+   Fires on: stakes (hard-to-reverse decision), confidence-without-evidence,
+   contradiction-present (an uncollided counter-take exists),
+   premature-convergence (one take survived unchallenged), or explicit
+   invocation. No tripped threshold = stand down, honestly. A controller
+   that always fires is noise.
+2. **Strongest Countermodel** — the strongest internally-coherent case
+   *against* the current conclusion. Steelman only: named premises, named
+   evidence, named mechanism. The package checks the countermodel
+   mechanically (see "Why it works") — a strawman fails the run. An
+   honest "I can't build a strong one" is a finding, not a failure.
+3. **Load-Bearing Assumptions** — every assumption the conclusion depends
+   on, marked **load-bearing** (if false, the conclusion falls) or
+   **structural** (supports it, but it survives without it). Only
+   load-bearing assumptions go to collision.
+4. **Collision** — the countermodel attacks each load-bearing assumption,
+   one at a time: **survives / weakened / broken**. Contradictions are
+   held in parallel non-subordinating sentences ("X is true. Y is also
+   true." — never "X, however Y"). The **surprise check**: if the
+   collision produced nothing neither side contained alone, it wasn't a
+   real collision — run it again, harder.
+5. **Confidence Revision** — before→after per assumption and overall.
+   The delta is the output. A broken load-bearing assumption doesn't
+   merely lower confidence — it **demotes the conclusion to a hypothesis**
+   pending new evidence. "I feel less sure" (self-report) is distinguished
+   from "the assumption broke under the countermodel" (finding).
+
+Core principle: **confidence and correctness are independent variables.**
+This tool interrogates the gap between them.
+
+## Why it works
+
+Most reasoning failures are structural, not intellectual. Confidence
+quietly outruns evidence. The first plausible story wins and alternatives
+never get built. Contradictions get smoothed with "however." The audit
+attacks all three mechanically:
+
+- **Trigger gating** means it only fires when the stakes or the
+  contradiction warrant it — no theater runs.
+- **The steelman check** (`steelman.py`) catches weak countermodels by
+  their mechanical signatures: too short to be specific, hedge phrases
+  with no named premises ("some might disagree..."), no evidence or
+  mechanism named, or a restatement of the conclusion in contrast
+  clothing. A weak countermodel fails the run before the collision can
+  be theater. This is the failure mode live-model evals found in small
+  models — checked in code, not just in prose.
+- **Load-bearing classification** focuses the collision where it can
+  change the conclusion. Colliding structural assumptions is motion
+  without effect.
+- **The demotion rule** makes broken assumptions costly: the conclusion
+  doesn't get a softer number, it gets demoted to a hypothesis.
+
+## Quickstart
+
+Zero dependencies beyond Python 3.10+ and a model to run the engine on.
+
+```bash
+cd metacog
+python3 -m unittest discover -s tests     # 39 offline tests — prove the machinery first
+```
+
+To run a real pressure test, you need a backend — any LLM that can follow
+the protocol prompt:
+
+```bash
+# Fully offline: local Ollama
+python3 examples/run_local.py reasoning.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 reasoning.txt --openrouter
+```
+
+`reasoning.txt` is plain prose:
+
+```
+CONCLUSION: Migrate billing to the new provider now
+REASONING: Costs are lower and churn will drop.
+EVIDENCE:
+- Quote: $38k migration
+- Q1 cohort churn 3.8%
+CONFIDENCE: 80
+```
+
+The engine returns a rendered collision record — the portable artifact.
+The engine never writes files and never claims external persistence:
+your code saves the record.
+
+Or use it as a library:
+
+```python
+from metacog import (
+    ReasoningInput, run, to_collision_record, OllamaBackend,
+)
+
+result = run(
+    ReasoningInput(
+        conclusion="Migrate billing to the new provider now",
+        reasoning="Costs are lower and churn will drop.",
+        evidence=["Quote: $38k migration", "Q1 cohort churn 3.8%"],
+        stated_confidence=80,
+        triggers=["stakes", "contradiction-present"],
+    ),
+    OllamaBackend(),
+)
+assert result.ok
+print(to_collision_record(result.record).render())
+```
+
+## Inputs, outputs
+
+- **Input:** a conclusion, the reasoning behind it (prose), optional
+  evidence, optional stated confidence, optional claimed triggers.
+- **Output:** a normalized record dict, or a rendered `collision-record`
+  Markdown document — complete, self-contained, no placeholders.
+
+## Worked example
+
+`examples/example-1-billing-migration.md` — a complete collision record
+for a business decision (migrate billing providers?), annotated so a
+stranger can follow each step.
+
+*The field is constructed for teaching — it shows the audit's shape, not
+real findings.*
+
+## FAQ
+
+**Does it replace the IFS interrogation engine?** No. It pressure-tests
+reasoning that already exists; IFS interrogates a field from scratch.
+They attach cleanly (the audit runs at the Collide→Refine boundary), but
+each works standalone.
+
+**Does it need an internet connection?** Only for the model call, and
+only the backend you choose. With Ollama it's fully offline. The 30 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.
+
+## License
+
+MIT. See LICENSE.

frontface_metacog-1.0.0/README.md

@@ -0,0 +1,163 @@
+# Confidence Auditor — five-step reasoning pressure test
+
+Interrogation, not supervision. You hand it reasoning-in-progress; it
+returns a **collision record** with a revised confidence — before→after,
+per load-bearing assumption and overall. It never originates analysis.
+It pressure-tests analysis that already exists.
+
+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 `metacog` skill from
+Ryan's skill-suite, MIT. What changed in the conversion is documented in
+CHANGELOG.md — the name and nothing else, really; this was already the
+cleanest skill in the suite.)*
+
+## What it does
+
+Five steps, in order, never reordered — evaluating before colliding is
+the most common failure mode (you polish claims that should have died):
+
+1. **Trigger Thresholds** — decide whether it's worth firing at all.
+   Fires on: stakes (hard-to-reverse decision), confidence-without-evidence,
+   contradiction-present (an uncollided counter-take exists),
+   premature-convergence (one take survived unchallenged), or explicit
+   invocation. No tripped threshold = stand down, honestly. A controller
+   that always fires is noise.
+2. **Strongest Countermodel** — the strongest internally-coherent case
+   *against* the current conclusion. Steelman only: named premises, named
+   evidence, named mechanism. The package checks the countermodel
+   mechanically (see "Why it works") — a strawman fails the run. An
+   honest "I can't build a strong one" is a finding, not a failure.
+3. **Load-Bearing Assumptions** — every assumption the conclusion depends
+   on, marked **load-bearing** (if false, the conclusion falls) or
+   **structural** (supports it, but it survives without it). Only
+   load-bearing assumptions go to collision.
+4. **Collision** — the countermodel attacks each load-bearing assumption,
+   one at a time: **survives / weakened / broken**. Contradictions are
+   held in parallel non-subordinating sentences ("X is true. Y is also
+   true." — never "X, however Y"). The **surprise check**: if the
+   collision produced nothing neither side contained alone, it wasn't a
+   real collision — run it again, harder.
+5. **Confidence Revision** — before→after per assumption and overall.
+   The delta is the output. A broken load-bearing assumption doesn't
+   merely lower confidence — it **demotes the conclusion to a hypothesis**
+   pending new evidence. "I feel less sure" (self-report) is distinguished
+   from "the assumption broke under the countermodel" (finding).
+
+Core principle: **confidence and correctness are independent variables.**
+This tool interrogates the gap between them.
+
+## Why it works
+
+Most reasoning failures are structural, not intellectual. Confidence
+quietly outruns evidence. The first plausible story wins and alternatives
+never get built. Contradictions get smoothed with "however." The audit
+attacks all three mechanically:
+
+- **Trigger gating** means it only fires when the stakes or the
+  contradiction warrant it — no theater runs.
+- **The steelman check** (`steelman.py`) catches weak countermodels by
+  their mechanical signatures: too short to be specific, hedge phrases
+  with no named premises ("some might disagree..."), no evidence or
+  mechanism named, or a restatement of the conclusion in contrast
+  clothing. A weak countermodel fails the run before the collision can
+  be theater. This is the failure mode live-model evals found in small
+  models — checked in code, not just in prose.
+- **Load-bearing classification** focuses the collision where it can
+  change the conclusion. Colliding structural assumptions is motion
+  without effect.
+- **The demotion rule** makes broken assumptions costly: the conclusion
+  doesn't get a softer number, it gets demoted to a hypothesis.
+
+## Quickstart
+
+Zero dependencies beyond Python 3.10+ and a model to run the engine on.
+
+```bash
+cd metacog
+python3 -m unittest discover -s tests     # 39 offline tests — prove the machinery first
+```
+
+To run a real pressure test, you need a backend — any LLM that can follow
+the protocol prompt:
+
+```bash
+# Fully offline: local Ollama
+python3 examples/run_local.py reasoning.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 reasoning.txt --openrouter
+```
+
+`reasoning.txt` is plain prose:
+
+```
+CONCLUSION: Migrate billing to the new provider now
+REASONING: Costs are lower and churn will drop.
+EVIDENCE:
+- Quote: $38k migration
+- Q1 cohort churn 3.8%
+CONFIDENCE: 80
+```
+
+The engine returns a rendered collision record — the portable artifact.
+The engine never writes files and never claims external persistence:
+your code saves the record.
+
+Or use it as a library:
+
+```python
+from metacog import (
+    ReasoningInput, run, to_collision_record, OllamaBackend,
+)
+
+result = run(
+    ReasoningInput(
+        conclusion="Migrate billing to the new provider now",
+        reasoning="Costs are lower and churn will drop.",
+        evidence=["Quote: $38k migration", "Q1 cohort churn 3.8%"],
+        stated_confidence=80,
+        triggers=["stakes", "contradiction-present"],
+    ),
+    OllamaBackend(),
+)
+assert result.ok
+print(to_collision_record(result.record).render())
+```
+
+## Inputs, outputs
+
+- **Input:** a conclusion, the reasoning behind it (prose), optional
+  evidence, optional stated confidence, optional claimed triggers.
+- **Output:** a normalized record dict, or a rendered `collision-record`
+  Markdown document — complete, self-contained, no placeholders.
+
+## Worked example
+
+`examples/example-1-billing-migration.md` — a complete collision record
+for a business decision (migrate billing providers?), annotated so a
+stranger can follow each step.
+
+*The field is constructed for teaching — it shows the audit's shape, not
+real findings.*
+
+## FAQ
+
+**Does it replace the IFS interrogation engine?** No. It pressure-tests
+reasoning that already exists; IFS interrogates a field from scratch.
+They attach cleanly (the audit runs at the Collide→Refine boundary), but
+each works standalone.
+
+**Does it need an internet connection?** Only for the model call, and
+only the backend you choose. With Ollama it's fully offline. The 30 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.
+
+## License
+
+MIT. See LICENSE.

frontface_metacog-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "frontface-metacog"
+version = "1.0.0"
+description = "Five-step reasoning pressure test: trigger thresholds, steelman countermodel, load-bearing assumptions, collision, confidence revision"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Ryan Wesley Hitchcock" }]
+keywords = ["reasoning", "metacognition", "red-teaming", "confidence", "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"]

frontface_metacog-1.0.0/setup.cfg

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

frontface_metacog-1.0.0/src/frontface_metacog.egg-info/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: frontface-metacog
+Version: 1.0.0
+Summary: Five-step reasoning pressure test: trigger thresholds, steelman countermodel, load-bearing assumptions, collision, confidence revision
+Author: Ryan Wesley Hitchcock
+License: MIT
+Project-URL: Homepage, https://github.com/ohpersonperson/frontface
+Keywords: reasoning,metacognition,red-teaming,confidence,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
+
+# Confidence Auditor — five-step reasoning pressure test
+
+Interrogation, not supervision. You hand it reasoning-in-progress; it
+returns a **collision record** with a revised confidence — before→after,
+per load-bearing assumption and overall. It never originates analysis.
+It pressure-tests analysis that already exists.
+
+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 `metacog` skill from
+Ryan's skill-suite, MIT. What changed in the conversion is documented in
+CHANGELOG.md — the name and nothing else, really; this was already the
+cleanest skill in the suite.)*
+
+## What it does
+
+Five steps, in order, never reordered — evaluating before colliding is
+the most common failure mode (you polish claims that should have died):
+
+1. **Trigger Thresholds** — decide whether it's worth firing at all.
+   Fires on: stakes (hard-to-reverse decision), confidence-without-evidence,
+   contradiction-present (an uncollided counter-take exists),
+   premature-convergence (one take survived unchallenged), or explicit
+   invocation. No tripped threshold = stand down, honestly. A controller
+   that always fires is noise.
+2. **Strongest Countermodel** — the strongest internally-coherent case
+   *against* the current conclusion. Steelman only: named premises, named
+   evidence, named mechanism. The package checks the countermodel
+   mechanically (see "Why it works") — a strawman fails the run. An
+   honest "I can't build a strong one" is a finding, not a failure.
+3. **Load-Bearing Assumptions** — every assumption the conclusion depends
+   on, marked **load-bearing** (if false, the conclusion falls) or
+   **structural** (supports it, but it survives without it). Only
+   load-bearing assumptions go to collision.
+4. **Collision** — the countermodel attacks each load-bearing assumption,
+   one at a time: **survives / weakened / broken**. Contradictions are
+   held in parallel non-subordinating sentences ("X is true. Y is also
+   true." — never "X, however Y"). The **surprise check**: if the
+   collision produced nothing neither side contained alone, it wasn't a
+   real collision — run it again, harder.
+5. **Confidence Revision** — before→after per assumption and overall.
+   The delta is the output. A broken load-bearing assumption doesn't
+   merely lower confidence — it **demotes the conclusion to a hypothesis**
+   pending new evidence. "I feel less sure" (self-report) is distinguished
+   from "the assumption broke under the countermodel" (finding).
+
+Core principle: **confidence and correctness are independent variables.**
+This tool interrogates the gap between them.
+
+## Why it works
+
+Most reasoning failures are structural, not intellectual. Confidence
+quietly outruns evidence. The first plausible story wins and alternatives
+never get built. Contradictions get smoothed with "however." The audit
+attacks all three mechanically:
+
+- **Trigger gating** means it only fires when the stakes or the
+  contradiction warrant it — no theater runs.
+- **The steelman check** (`steelman.py`) catches weak countermodels by
+  their mechanical signatures: too short to be specific, hedge phrases
+  with no named premises ("some might disagree..."), no evidence or
+  mechanism named, or a restatement of the conclusion in contrast
+  clothing. A weak countermodel fails the run before the collision can
+  be theater. This is the failure mode live-model evals found in small
+  models — checked in code, not just in prose.
+- **Load-bearing classification** focuses the collision where it can
+  change the conclusion. Colliding structural assumptions is motion
+  without effect.
+- **The demotion rule** makes broken assumptions costly: the conclusion
+  doesn't get a softer number, it gets demoted to a hypothesis.
+
+## Quickstart
+
+Zero dependencies beyond Python 3.10+ and a model to run the engine on.
+
+```bash
+cd metacog
+python3 -m unittest discover -s tests     # 39 offline tests — prove the machinery first
+```
+
+To run a real pressure test, you need a backend — any LLM that can follow
+the protocol prompt:
+
+```bash
+# Fully offline: local Ollama
+python3 examples/run_local.py reasoning.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 reasoning.txt --openrouter
+```
+
+`reasoning.txt` is plain prose:
+
+```
+CONCLUSION: Migrate billing to the new provider now
+REASONING: Costs are lower and churn will drop.
+EVIDENCE:
+- Quote: $38k migration
+- Q1 cohort churn 3.8%
+CONFIDENCE: 80
+```
+
+The engine returns a rendered collision record — the portable artifact.
+The engine never writes files and never claims external persistence:
+your code saves the record.
+
+Or use it as a library:
+
+```python
+from metacog import (
+    ReasoningInput, run, to_collision_record, OllamaBackend,
+)
+
+result = run(
+    ReasoningInput(
+        conclusion="Migrate billing to the new provider now",
+        reasoning="Costs are lower and churn will drop.",
+        evidence=["Quote: $38k migration", "Q1 cohort churn 3.8%"],
+        stated_confidence=80,
+        triggers=["stakes", "contradiction-present"],
+    ),
+    OllamaBackend(),
+)
+assert result.ok
+print(to_collision_record(result.record).render())
+```
+
+## Inputs, outputs
+
+- **Input:** a conclusion, the reasoning behind it (prose), optional
+  evidence, optional stated confidence, optional claimed triggers.
+- **Output:** a normalized record dict, or a rendered `collision-record`
+  Markdown document — complete, self-contained, no placeholders.
+
+## Worked example
+
+`examples/example-1-billing-migration.md` — a complete collision record
+for a business decision (migrate billing providers?), annotated so a
+stranger can follow each step.
+
+*The field is constructed for teaching — it shows the audit's shape, not
+real findings.*
+
+## FAQ
+
+**Does it replace the IFS interrogation engine?** No. It pressure-tests
+reasoning that already exists; IFS interrogates a field from scratch.
+They attach cleanly (the audit runs at the Collide→Refine boundary), but
+each works standalone.
+
+**Does it need an internet connection?** Only for the model call, and
+only the backend you choose. With Ollama it's fully offline. The 30 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.
+
+## License
+
+MIT. See LICENSE.

frontface_metacog-1.0.0/src/frontface_metacog.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/frontface_metacog.egg-info/PKG-INFO
+src/frontface_metacog.egg-info/SOURCES.txt
+src/frontface_metacog.egg-info/dependency_links.txt
+src/frontface_metacog.egg-info/top_level.txt
+src/metacog/__init__.py
+src/metacog/backends.py
+src/metacog/engine.py
+src/metacog/ledger.py
+src/metacog/protocol.py
+src/metacog/record.py
+src/metacog/steelman.py
+src/metacog/triggers.py
+tests/test_ledger.py
+tests/test_record_engine.py
+tests/test_triggers_protocol.py

frontface_metacog-1.0.0/src/frontface_metacog.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

frontface_metacog-1.0.0/src/frontface_metacog.egg-info/top_level.txt

@@ -0,0 +1 @@
+metacog

frontface_metacog-1.0.0/src/metacog/__init__.py

@@ -0,0 +1,40 @@
+"""metacog — front-facing conversion of the metacog skill.
+
+A five-step reasoning pressure test: check whether it is worth firing at
+all (trigger thresholds), steelman the strongest countermodel, isolate
+load-bearing assumptions, collide the countermodel against each one, and
+revise confidence with a before→after delta.
+
+Core invariant: confidence and correctness are independent variables.
+See README.md for the plain-language version. See CHANGELOG.md for what
+was decoupled from the original skill.
+"""
+
+from . import backends, engine, protocol, record, steelman, triggers
+from .backends import StubBackend, OpenRouterBackend, OllamaBackend
+from .engine import (
+    LLMBackend, RunResult, ReasoningInput, build_user_message,
+    parse_model_json, normalize, run, to_collision_record,
+)
+from .protocol import (
+    SYSTEM_PROMPT, Countermodel, Assumption, CollisionResult,
+    ConfidenceRevision, ProtocolError, apply_demotions,
+    LOAD_BEARING, STRUCTURAL, SURVIVES, WEAKENED, BROKEN,
+)
+from .record import CollisionRecord, RecordError
+from .steelman import SteelmanReport, check_countermodel
+from .triggers import TriggerEvaluation, TriggerError, TRIGGERS
+
+__version__ = "1.0.0"
+__all__ = [
+    "backends", "engine", "protocol", "record", "steelman", "triggers",
+    "StubBackend", "OpenRouterBackend", "OllamaBackend",
+    "LLMBackend", "RunResult", "ReasoningInput", "build_user_message",
+    "parse_model_json", "normalize", "run", "to_collision_record",
+    "SYSTEM_PROMPT", "Countermodel", "Assumption", "CollisionResult",
+    "ConfidenceRevision", "ProtocolError", "apply_demotions",
+    "LOAD_BEARING", "STRUCTURAL", "SURVIVES", "WEAKENED", "BROKEN",
+    "CollisionRecord", "RecordError",
+    "SteelmanReport", "check_countermodel",
+    "TriggerEvaluation", "TriggerError", "TRIGGERS",
+]