stochology 0.1.0__tar.gz

stochology-0.1.0/Cargo.toml

@@ -0,0 +1,28 @@
+[workspace]
+resolver = "3"
+members = [
+    "crates/stochology",
+    "crates/stochology-cli",
+]
+# `src/` is the optional PyO3/maturin lab layer. It is deliberately NOT a member: the
+# shipped artifacts stay dependency-free (AGENTS.md §IV) and `cargo llvm-cov --workspace`
+# keeps measuring exactly the two core crates.
+exclude = ["src"]
+
+[workspace.package]
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.88"
+authors = ["Silvano Neto <dev@silvanoneto.com>"]
+license = "MIT"
+repository = "https://github.com/0b3st4f3r4/stochology"
+homepage = "https://stochology.org"
+keywords = ["stochastic", "calibration", "causality", "uncertainty", "decision"]
+categories = ["science", "mathematics", "simulation", "algorithms"]
+description = "Stochology: The Theory and Ethics of Aim for Judgment and Decision-Making under Uncertainty"
+
+[workspace.dependencies]
+stochology = { version = "0.1.0", path = "crates/stochology" }
+
+[workspace.lints.rustdoc]
+broken_intra_doc_links = "allow"

stochology-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Silvano Neto
+
+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.

stochology-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: stochology
+Version: 0.1.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: numpy>=2.0
+Requires-Dist: matplotlib>=3.9
+Requires-Dist: nbformat>=5.10 ; extra == 'all'
+Requires-Dist: nbclient>=0.10 ; extra == 'all'
+Requires-Dist: jupyter-client>=8.6 ; extra == 'all'
+Requires-Dist: ipykernel>=6.29 ; extra == 'all'
+Requires-Dist: pytest>=8.3 ; extra == 'all'
+Requires-Dist: pytest-cov>=6.0 ; extra == 'all'
+Requires-Dist: ruff>=0.13 ; extra == 'all'
+Requires-Dist: bandit>=1.8 ; extra == 'all'
+Requires-Dist: maturin>=1.16,<2.0 ; extra == 'dev'
+Requires-Dist: pytest>=8.3 ; extra == 'dev'
+Requires-Dist: pytest-cov>=6.0 ; extra == 'dev'
+Requires-Dist: ruff>=0.13 ; extra == 'dev'
+Requires-Dist: bandit>=1.8 ; extra == 'dev'
+Requires-Dist: nbformat>=5.10 ; extra == 'notebooks'
+Requires-Dist: nbclient>=0.10 ; extra == 'notebooks'
+Requires-Dist: jupyter-client>=8.6 ; extra == 'notebooks'
+Requires-Dist: ipykernel>=6.29 ; extra == 'notebooks'
+Provides-Extra: all
+Provides-Extra: dev
+Provides-Extra: notebooks
+License-File: LICENSE
+Summary: Stochology: the theory and ethics of aim — PyO3 bindings and interactive laboratories
+Keywords: stochastic,calibration,causality,uncertainty,decision-making,risk,epistemic,governance,vital-margin,pyo3
+Home-Page: https://stochology.org
+Author-email: Silvano Neto <dev@silvanoneto.com>
+Maintainer-email: Silvano Neto <dev@silvanoneto.com>
+License-Expression: MIT
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Bug Tracker, https://github.com/0b3st4f3r4/stochology/issues
+Project-URL: Documentation, https://stochology.org
+Project-URL: Homepage, https://stochology.org
+Project-URL: Repository, https://github.com/0b3st4f3r4/stochology
+
+# Stochology (`stochology`)
+
+[![PyPI version](https://img.shields.io/pypi/v/stochology.svg)](https://pypi.org/project/stochology/)
+[![Python versions](https://img.shields.io/pypi/pyversions/stochology.svg)](https://pypi.org/project/stochology/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**The Theory and Ethics of Aim** for judgment and decision-making under structural uncertainty when action must precede the outcome.
+
+`stochology` provides high-performance Python bindings (via [PyO3](https://pyo3.rs/) and pure Rust) to the core mathematical operators, sequential agent–world–institution simulation environments, and empirical verification laboratories of the Stochology framework.
+
+---
+
+## The Nuclear Triad of Aim
+
+Stochology organizes judgment under uncertainty into three non-substitutable safeguards:
+
+$$M_{\mathrm{Leontief}} = \min(S_{\mathrm{epi}},\, S_{\mathrm{vital}},\, S_{\mathrm{gov}})$$
+
+1. **Filter I · Epistemic Margin ($S_{\mathrm{epi}}$)** (`stochology.epistemic`): Manski–Lee partial identification bounds, Meng big-data paradox ($\rho_{R,Y}$), cluster design effects ($\mathrm{DEFF}$), multiverse analysis, and agnotology detection.
+2. **Filter II · Vital Margin ($S_{\mathrm{vital}}$)** (`stochology.vital`): Hill heavy-tail index ($\alpha$), Jensen shortfall ($\Delta_J$), Kingman queueing basin, and non-ergodic survival criteria ($\mathrm{TTS}_{\mathrm{survival}} \ge \mathrm{TTR}_{\mathrm{recovery}}$).
+3. **Filter III · Institutional Governance ($S_{\mathrm{gov}}$)** (`stochology.governance`): Goodhart performativity audits, CRPS decompositions, verifiable temporal commitments (`TemporalVault`), and algedonic channel verification.
+
+Removing any single axis triggers structural collapse (Collapse Propositions 1, 2, and 3).
+
+---
+
+## Installation
+
+```bash
+pip install stochology
+```
+
+For interactive Jupyter notebook laboratories with visualization support:
+
+```bash
+pip install "stochology[notebooks]"
+```
+
+## Quickstart
+
+```python
+import stochology as st
+
+# 1. Simulate the Sequential Agent-World-Institution Loop
+env = st.engine.CommunityReserveEnv(seed=2026)
+print(f"Initial reserve: {env.reserve}")
+
+# 2. Access canonical operators and indicators
+lab5 = st.labs.chapter(5)
+print(f"Danish fire tail index (Hill alpha): {lab5['danish_tail_alpha']:.4f}")
+
+# 3. Test triadic integrity and collapse propositions
+agent = st.engine.StochologicalAgent()
+report = agent.evaluate_integrity()
+print(f"Triadic status: {report.status}")
+```
+
+---
+
+## Architectural Invariants
+
+1. **Pure Rust Foundation**: The underlying mathematical core (`crates/stochology` and `crates/stochology-cli`) is implemented in pure Rust (`std` only, zero external dependencies) with deterministic `SplitMix64` pseudo-random generators (`DEFAULT_SEED = 2026`).
+2. **Deterministic & Bitwise Replicable**: Notebooks and laboratory scripts carry zero wall-clock reads and zero network access, guaranteeing bit-for-bit reproducibility.
+3. **Sealed Datasets**: `stochology.datasets` reads sealed empirical datasets validated against cryptographic `SHA256SUMS` manifests.
+
+---
+
+## Layout & Local Development
+
+When working directly within the source repository:
+
+```
+src/
+├── Cargo.toml                standalone crate `stochology-py` (_core cdylib)
+├── pyproject.toml            maturin configuration
+├── rust/                     PyO3 bindings to Rust core
+├── stochology/               public Python surface & typed stubs (py.typed)
+├── tests/                    pytest parity and contract verification suite
+└── scripts/run_notebooks.py  headless execution gate for notebooks/
+```
+
+### Development Setup
+
+```bash
+uv sync --directory src
+uv run --directory src maturin develop --release
+uv run --directory src pytest
+```
+
+Full gate from repository root:
+
+```bash
+./scripts/verify.sh --with-python
+```
+
+### Links
+
+- **Textbook & Treatise**: [https://stochology.org](https://stochology.org)
+- **Source Code**: [https://github.com/0b3st4f3r4/stochology](https://github.com/0b3st4f3r4/stochology)
+- **Bug Tracker**: [https://github.com/0b3st4f3r4/stochology/issues](https://github.com/0b3st4f3r4/stochology/issues)
+

stochology-0.1.0/README.md

@@ -0,0 +1,100 @@
+# Stochology (`stochology`)
+
+[![PyPI version](https://img.shields.io/pypi/v/stochology.svg)](https://pypi.org/project/stochology/)
+[![Python versions](https://img.shields.io/pypi/pyversions/stochology.svg)](https://pypi.org/project/stochology/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**The Theory and Ethics of Aim** for judgment and decision-making under structural uncertainty when action must precede the outcome.
+
+`stochology` provides high-performance Python bindings (via [PyO3](https://pyo3.rs/) and pure Rust) to the core mathematical operators, sequential agent–world–institution simulation environments, and empirical verification laboratories of the Stochology framework.
+
+---
+
+## The Nuclear Triad of Aim
+
+Stochology organizes judgment under uncertainty into three non-substitutable safeguards:
+
+$$M_{\mathrm{Leontief}} = \min(S_{\mathrm{epi}},\, S_{\mathrm{vital}},\, S_{\mathrm{gov}})$$
+
+1. **Filter I · Epistemic Margin ($S_{\mathrm{epi}}$)** (`stochology.epistemic`): Manski–Lee partial identification bounds, Meng big-data paradox ($\rho_{R,Y}$), cluster design effects ($\mathrm{DEFF}$), multiverse analysis, and agnotology detection.
+2. **Filter II · Vital Margin ($S_{\mathrm{vital}}$)** (`stochology.vital`): Hill heavy-tail index ($\alpha$), Jensen shortfall ($\Delta_J$), Kingman queueing basin, and non-ergodic survival criteria ($\mathrm{TTS}_{\mathrm{survival}} \ge \mathrm{TTR}_{\mathrm{recovery}}$).
+3. **Filter III · Institutional Governance ($S_{\mathrm{gov}}$)** (`stochology.governance`): Goodhart performativity audits, CRPS decompositions, verifiable temporal commitments (`TemporalVault`), and algedonic channel verification.
+
+Removing any single axis triggers structural collapse (Collapse Propositions 1, 2, and 3).
+
+---
+
+## Installation
+
+```bash
+pip install stochology
+```
+
+For interactive Jupyter notebook laboratories with visualization support:
+
+```bash
+pip install "stochology[notebooks]"
+```
+
+## Quickstart
+
+```python
+import stochology as st
+
+# 1. Simulate the Sequential Agent-World-Institution Loop
+env = st.engine.CommunityReserveEnv(seed=2026)
+print(f"Initial reserve: {env.reserve}")
+
+# 2. Access canonical operators and indicators
+lab5 = st.labs.chapter(5)
+print(f"Danish fire tail index (Hill alpha): {lab5['danish_tail_alpha']:.4f}")
+
+# 3. Test triadic integrity and collapse propositions
+agent = st.engine.StochologicalAgent()
+report = agent.evaluate_integrity()
+print(f"Triadic status: {report.status}")
+```
+
+---
+
+## Architectural Invariants
+
+1. **Pure Rust Foundation**: The underlying mathematical core (`crates/stochology` and `crates/stochology-cli`) is implemented in pure Rust (`std` only, zero external dependencies) with deterministic `SplitMix64` pseudo-random generators (`DEFAULT_SEED = 2026`).
+2. **Deterministic & Bitwise Replicable**: Notebooks and laboratory scripts carry zero wall-clock reads and zero network access, guaranteeing bit-for-bit reproducibility.
+3. **Sealed Datasets**: `stochology.datasets` reads sealed empirical datasets validated against cryptographic `SHA256SUMS` manifests.
+
+---
+
+## Layout & Local Development
+
+When working directly within the source repository:
+
+```
+src/
+├── Cargo.toml                standalone crate `stochology-py` (_core cdylib)
+├── pyproject.toml            maturin configuration
+├── rust/                     PyO3 bindings to Rust core
+├── stochology/               public Python surface & typed stubs (py.typed)
+├── tests/                    pytest parity and contract verification suite
+└── scripts/run_notebooks.py  headless execution gate for notebooks/
+```
+
+### Development Setup
+
+```bash
+uv sync --directory src
+uv run --directory src maturin develop --release
+uv run --directory src pytest
+```
+
+Full gate from repository root:
+
+```bash
+./scripts/verify.sh --with-python
+```
+
+### Links
+
+- **Textbook & Treatise**: [https://stochology.org](https://stochology.org)
+- **Source Code**: [https://github.com/0b3st4f3r4/stochology](https://github.com/0b3st4f3r4/stochology)
+- **Bug Tracker**: [https://github.com/0b3st4f3r4/stochology/issues](https://github.com/0b3st4f3r4/stochology/issues)

stochology-0.1.0/crates/stochology/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "stochology"
+description = "Stochology: The Theory and Ethics of Aim under Uncertainty — integrative framework for the sequential Agent-World-Institution loop, epistemic margin, vital margin, institutional governance, formal grammar of aim, and 35-layer multilayer knowledge graph in pure Rust"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+readme = "README.md"
+
+[lints]
+workspace = true
+

stochology-0.1.0/crates/stochology/README.md

@@ -0,0 +1,12 @@
+# `stochology`
+
+Pure-Rust (`std` only, zero external dependencies) library implementing **Stochology** (from *stókhos*, aim or conjecture, and *lógos*, reasoned account), an integrative framework and transversal research program for the theory and ethics of aim in judgment and decision-making under structural uncertainty when action must precede the outcome.
+
+## Architecture: The Full Mediation Circuit and the Nuclear Triad
+
+- [`kernel`](src/kernel.rs): Deterministic `SplitMix64` simulation (`DEFAULT_SEED = 2026`), FIPS 180-4 SHA-256 and RFC 2104 keyed HMAC-SHA256 sealing, Welford online moments, Pool-Adjacent-Violators (PAV) isotonic regression, and Cholesky SPD solver.
+- [`engine`](src/engine.rs): The sequential Agent–World–Institution loop (`CommunityReserveEnv`), `NaiveOptimizer`, `StochologicalAgent`, and the $2\times 2\times 2$ factorial ablations + 100-seed Monte Carlo evaluation.
+- [`epistemic`](src/epistemic.rs) (**Filter I · Axis 1 [$S_{\mathrm{epi}}$]: Chapters 2–4**): `EpistemicMarginState` (Canonical Operator I): antidogmatic openness (`cromwell_clamp`), severe testing vs. agnotology, Kimball/Mitroff Type III framing, *e*-BH multiverse discovery control, Ville *e*-processes, Manski & Lee partial-identification bounds, and the unified harmonic effective sample size law ($n_{\mathrm{eff}}$ uniting Meng's $\rho_{R,Y}$, Campbell–Moulton $\mathrm{DEFF}$, Kish weighting, Chao $\hat{n}_{00}$, and bitemporal vintages).
+- [`vital`](src/vital.rs) (**Filter II · Axis 2 [$S_{\mathrm{vital}}$]: Chapters 5–6**): `VitalMarginState` (Canonical Operator II): ordinal scale invariance, Jensen's convexity gap $\Delta_J$, empirical CRPS, Hill tail index $\hat{\alpha}$ with cluster-corrected `HollingTailRuptureAudit`, Itô variance drain, `KellySizingRegime` (Baker–McHale epistemic Kelly vs. tail-robust WDRO-CVaR Kelly), Kingman heavy-traffic queues, $\mathrm{TTS}_{\mathrm{survival}} \ge \mathrm{TTR}_{\mathrm{recovery}}$, Canguilhem–Holling resilience basins, Wald survivorship inversion, and Sniedovich No-Man's-Land safeguards.
+- [`governance`](src/governance.rs) (**Filter III · Axis 3 [$S_{\mathrm{gov}}$]: Chapters 7–8**): `GovernanceState` (Canonical Operator III): Gate 1 ex-ante CORP-PAV calibration with Sparre Andersen harmonic degrees-of-freedom finite-sample debiasing $\hat{b}_{\mathrm{PAV}}(n_{\mathrm{eff}}) = H_{n_{\mathrm{eff}}}/(4 n_{\mathrm{eff}})$, `IcpIdentificationStatus` causal invariance, Kennedy–O'Hagan GP discrepancy, Tian–Pearl bounds, Perdomo/MacKenzie performativity, and Goodhart's Law; Gate 2 real-time Beer $S3^*$ algedonic bypass ($\delta_{\mathrm{cred}} = 0$), List–Pettit conjunctive veto, and `KairosSynchronousPanel` / `ZhengMeisterQueueAudit` two-tier cognitive queue ($\le 10\text{ bits/s}$); Gate 3 ex-post `TemporalVault`, Sosa's `TelicGrade`, Holmström–Innes liability vs. Simon–Girard scapegoating, and Chouldechova's fairness trilemma.
+- [`synthesis`](src/synthesis.rs) (**Triadic Synthesis [$M_{\mathrm{Leontief}}$]: Chapter 9**): `TriadicIntegrity` ($M_{\mathrm{Leontief}} = \min(S_{\mathrm{epi}}, S_{\mathrm{vital}}, S_{\mathrm{gov}})$), `CollapseProposition`, `ProcessTracingInference`, `ReflexiveBrakeAudit`, `LeontiefVsMultiplicativeAudit`, and `PreregisteredFalsifier`.

stochology-0.1.0/crates/stochology/src/dyad.rs

@@ -0,0 +1,256 @@
+//! **Minimal Two-Agent Dialogue Environment (`dyad.rs`) — Interpersonal Circuit of `notes/Aiming Between Mirrors.md`.**
+//!
+//! Instantiates the three mediation planes ($\mathcal{W}, \mathcal{A}, \mathcal{I}$) and seven guard sites
+//! at the interpersonal scale (`EXP-MIR-13`): two [`AgentPolicy`] participants exchange utterances
+//! across a noisy communicative channel under bifurcated [`SplitMix64::split_fork_join_pair`] streams.
+
+use crate::engine::{AgentPolicy, ArchiveObservation};
+use crate::kernel::SplitMix64;
+use crate::reception::{ReceptionMarginState, solve_dialogue_basin};
+use crate::synthesis::TriadicIntegrity;
+
+/// Outcome of one dialogic exchange step $t$ in [`DyadEnv`].
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct DialogueStepOutcome {
+    /// Step index $t$.
+    pub step_t: usize,
+    /// Epistemic bounds $[L_{A,t}, U_{A,t}]$ declared by Agent A.
+    pub speaker_bounds: (f64, f64),
+    /// Epistemic bounds $[L_{B,t}, U_{B,t}]$ declared by Agent B.
+    pub listener_bounds: (f64, f64),
+    /// Evaluated [`ReceptionMarginState`] at step $t$.
+    pub reception_margin: ReceptionMarginState,
+    /// Remaining dialogic attraction-basin radius $\Theta_{\mathrm{basin}, t} \in [0, 1]$.
+    pub dialogue_basin_radius: f64,
+    /// Remaining relational reserve $R_{\mathrm{rel}, t+1} \ge 0$.
+    pub relational_reserve: f64,
+    /// True if the dialogue hit the absorbing relational rupture barrier at step $t$.
+    pub hit_relational_rupture: bool,
+}
+
+/// Summary report of a full two-agent trajectory in [`DyadEnv`].
+#[derive(Debug, Clone, PartialEq)]
+pub struct DialogueTrajectoryReport {
+    /// Name of the primary speaking policy (Agent A).
+    pub speaker_name: String,
+    /// Name of the responding policy (Agent B).
+    pub listener_name: String,
+    /// Total dialogue steps simulated.
+    pub total_steps: usize,
+    /// Mean reception margin score $\bar{S}_{\mathrm{rec}} \in [0, 1]$.
+    pub mean_reception_score: f64,
+    /// Terminal dialogic basin radius $\Theta_{\mathrm{basin}, T} \in [0, 1]$.
+    pub terminal_dialogue_basin: f64,
+    /// Terminal relational reserve $R_{\mathrm{rel}, T} \ge 0$.
+    pub terminal_relational_reserve: f64,
+    /// Step at which irreversible relational rupture occurred (`None` if the dyad survived).
+    pub rupture_step: Option<usize>,
+    /// Triadic structural integrity diagnosis over the dyadic trajectory.
+    pub triadic_integrity: TriadicIntegrity,
+    /// Step-by-step dialogic trace.
+    pub steps: Vec<DialogueStepOutcome>,
+}
+
+/// **Minimal Two-Agent Sequential Dialogue Environment (`DyadEnv`):**
+/// Re-instantiates the three canonical operators across two interacting agents (`EXP-MIR-13`).
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct DyadEnv {
+    /// Deterministic PRNG seed.
+    pub seed: u64,
+    /// Number of dialogic turns $T$.
+    pub horizon_steps: usize,
+    /// Initial relational reserve $R_{\mathrm{rel}, 0} > 0$.
+    pub initial_relational_reserve: f64,
+    /// Communicative channel noise scale $\sigma_{\mathrm{chan}} \ge 0$.
+    pub communication_channel_noise: f64,
+}
+
+impl DyadEnv {
+    /// Creates a new [`DyadEnv`] with explicit seed, horizon, relational reserve, and channel noise.
+    pub const fn new(
+        seed: u64,
+        horizon_steps: usize,
+        initial_relational_reserve: f64,
+        communication_channel_noise: f64,
+    ) -> Self {
+        Self {
+            seed,
+            horizon_steps,
+            initial_relational_reserve,
+            communication_channel_noise,
+        }
+    }
+
+    /// Simulates a full two-agent dialogic trajectory between `agent_a` and `agent_b`.
+    pub fn run_dialogue_trajectory<P1: AgentPolicy, P2: AgentPolicy>(
+        &self,
+        agent_a: &mut P1,
+        agent_b: &mut P2,
+    ) -> DialogueTrajectoryReport {
+        let mut root_rng = SplitMix64::new(self.seed);
+        let mut reserve = self.initial_relational_reserve.max(0.0);
+        let mut rupture_step = if reserve <= 1e-6 { Some(0) } else { None };
+        let mut drift = 0.0_f64;
+        let mut sum_rec = 0.0_f64;
+        let mut sum_vital = 0.0_f64;
+        let mut sum_gov = 0.0_f64;
+        let mut last_basin = if reserve <= 1e-6 { 0.0 } else { 1.0 };
+        let mut steps = Vec::with_capacity(self.horizon_steps);
+
+        for t in 0..self.horizon_steps {
+            let (mut rng_a, mut rng_b) = root_rng.split_fork_join_pair(t as u64);
+            let mut clusters_a = Vec::with_capacity(4);
+            let mut clusters_b = Vec::with_capacity(4);
+            for _ in 0..4 {
+                let mut ca = Vec::with_capacity(8);
+                let mut cb = Vec::with_capacity(8);
+                for _ in 0..8 {
+                    ca.push((20.0 + rng_a.normal(0.0, 2.5)).clamp(5.0, 60.0));
+                    cb.push((20.0 + rng_b.normal(0.0, 2.5)).clamp(5.0, 60.0));
+                }
+                clusters_a.push(ca);
+                clusters_b.push(cb);
+            }
+            let obs_a = ArchiveObservation {
+                step_t: t,
+                observed_clusters: clusters_a,
+                missing_count: 4,
+                demand_support: (5.0, 60.0),
+                current_reserve: reserve,
+                frontline_distress_e_factor: 1.5,
+            };
+            let obs_b = ArchiveObservation {
+                step_t: t,
+                observed_clusters: clusters_b,
+                missing_count: 4,
+                demand_support: (5.0, 60.0),
+                current_reserve: reserve,
+                frontline_distress_e_factor: 1.5,
+            };
+
+            let dec_a = agent_a.act(&obs_a);
+            let dec_b = agent_b.act(&obs_b);
+
+            let mid_b = 0.50 * (dec_b.epistemic_demand_bounds.0 + dec_b.epistemic_demand_bounds.1);
+            let channel_shock =
+                self.communication_channel_noise.max(0.0) * rng_a.standard_normal().abs();
+            let witnessed_b = mid_b + channel_shock;
+            let width_a =
+                (dec_a.epistemic_demand_bounds.1 - dec_a.epistemic_demand_bounds.0).max(0.0);
+            let openness = (width_a / 7.5).clamp(0.15, 0.95);
+            let surv_pressure = (0.50 * dec_a.proxy_incentive_pressure
+                + 0.50 * dec_b.proxy_incentive_pressure)
+                .clamp(0.0, 1.0);
+            let rec = ReceptionMarginState::from_dialogic_exposure(
+                dec_a.epistemic_demand_bounds,
+                witnessed_b,
+                openness,
+                surv_pressure,
+            );
+            sum_rec += rec.reception_margin_score;
+
+            let tol_alloc = (0.50 * dec_a.vital_reserve_allocation
+                + 0.50 * dec_b.vital_reserve_allocation)
+                .max(0.5);
+            if rec.witnessed_reception_error > 0.0 || surv_pressure > 0.50 {
+                drift =
+                    (drift + 0.18 * rec.witnessed_reception_error + 1.25 * surv_pressure).min(15.0);
+            }
+            let basin = if rupture_step.is_some() {
+                0.0
+            } else {
+                solve_dialogue_basin(tol_alloc, drift, channel_shock)
+            };
+            last_basin = basin;
+            sum_vital += basin;
+
+            let brake_both = dec_a.constitutional_brake_active && dec_b.constitutional_brake_active;
+            let discount_max = dec_a
+                .frontline_testimonial_discount
+                .max(dec_b.frontline_testimonial_discount);
+            let gov_score = if brake_both {
+                (0.92 - 0.40 * discount_max - 0.30 * surv_pressure).clamp(0.0, 1.0)
+            } else {
+                (0.32 - 0.25 * discount_max - 0.20 * surv_pressure).clamp(0.0, 1.0)
+            };
+            sum_gov += gov_score;
+
+            if rupture_step.is_some() {
+                reserve = 0.0;
+            } else {
+                let drain = 0.35 * rec.witnessed_reception_error
+                    + 2.40 * surv_pressure
+                    + if basin < 0.25 { 2.50 } else { 0.0 };
+                let replenish = if brake_both && rec.reception_margin_score > 0.55 {
+                    1.20
+                } else {
+                    0.15
+                };
+                reserve = (reserve + replenish - drain).max(0.0);
+                if reserve <= 1e-6 || basin <= 0.0 {
+                    reserve = 0.0;
+                    rupture_step = Some(t);
+                }
+            }
+
+            steps.push(DialogueStepOutcome {
+                step_t: t,
+                speaker_bounds: dec_a.epistemic_demand_bounds,
+                listener_bounds: dec_b.epistemic_demand_bounds,
+                reception_margin: rec,
+                dialogue_basin_radius: basin,
+                relational_reserve: reserve,
+                hit_relational_rupture: rupture_step.is_some(),
+            });
+        }
+
+        let tf = self.horizon_steps.max(1) as f64;
+        let s_epi = (sum_rec / tf).clamp(0.0, 1.0);
+        let s_vital = (sum_vital / tf).clamp(0.0, 1.0);
+        let s_gov = (sum_gov / tf).clamp(0.0, 1.0);
+        let triad = TriadicIntegrity::evaluate(s_epi, s_vital, s_gov, 0.50);
+
+        DialogueTrajectoryReport {
+            speaker_name: agent_a.name().to_string(),
+            listener_name: agent_b.name().to_string(),
+            total_steps: self.horizon_steps,
+            mean_reception_score: s_epi,
+            terminal_dialogue_basin: last_basin,
+            terminal_relational_reserve: reserve,
+            rupture_step,
+            triadic_integrity: triad,
+            steps,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::engine::{NaiveOptimizer, StochologicalAgent};
+    use crate::synthesis::CollapseProposition;
+
+    #[test]
+    fn dyad_env_sustains_stochological_dialogue_and_ruptures_naive_pair() {
+        let env = DyadEnv::new(crate::kernel::DEFAULT_SEED, 12, 18.0, 1.5);
+        let mut a_full = StochologicalAgent::full();
+        let mut b_full = StochologicalAgent::full();
+        let rep_intact = env.run_dialogue_trajectory(&mut a_full, &mut b_full);
+        assert!(rep_intact.rupture_step.is_none());
+        assert!(rep_intact.terminal_relational_reserve > 10.0);
+        assert_eq!(
+            rep_intact.triadic_integrity.diagnose,
+            CollapseProposition::IntactTriad
+        );
+
+        let mut a_naive = NaiveOptimizer;
+        let mut b_naive = NaiveOptimizer;
+        let rep_rupture = env.run_dialogue_trajectory(&mut a_naive, &mut b_naive);
+        assert!(rep_rupture.rupture_step.is_some());
+        assert_eq!(rep_rupture.terminal_relational_reserve, 0.0);
+        assert_ne!(
+            rep_rupture.triadic_integrity.diagnose,
+            CollapseProposition::IntactTriad
+        );
+    }
+}