diff --git a/CHANGELOG.md b/CHANGELOG.md
index 062a69412..1e3720a54 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -38,6 +38,8 @@ All notable changes to TEPP are documented here. The format follows Keep a Chang
 
 ## [Unreleased]
 
+- **Subevent-containment analysis-run profile**: `analysis_engine` binds existing `subevent_containment::EventInterval` and `refuse_escaped_subevent` to cutoff-safe `subevent_containment_v1` (`tepp.subevent_containment.v1`) with inference status `subevent_interval_cannot_escape_parent_interval`. `containment_recovery_rate` and `identity_recovery_rate` stay library-side. Not episode-membership, not inferred-status, not relation-absence, not outcome-order, not membership-target, not location-membership, not membership-posterior ICC, not copied-text, not copy-identity, not citation-edge, not GPU, not MCMC, and not topic birth/split/merge.
+
 - `event_core` adds bounded Allen interval-consistency classification, atomic path-consistency closure, contradiction/resource refusals, and an explicit dependency-error fallback without claiming unrestricted global satisfiability.
 
 - `psychometric_core` recovers the Driver, Oud, and Voelkle (2017, Table 2, p. 12 `MANIFESTTRAITVAR`; §7.1, p. 19; p. 16 `MANIFESTTRAITVARstd`; footnote 4; 2017-era ctsem `summary.ctsemFit.R`; JSS PDF re-opened 2026-08-27T14:20Z from https://www.jstatsoft.org/index.php/jss/article/download/v077i05/1104) scalar standardised manifest-trait variance on current main after `0ce16e8` dropped the pre-consolidation code while research notes already named the map (register items 83–84). Table 2 names `MANIFESTTRAITVAR` `Ψ_τ` the additional time-invariant variance-covariance on the measurement level and sets it `NULL` when there is no manifest trait. Equation 5 writes `Γ ~ N(τ, Ψ)` and names that covariance the manifest traits. Section 7.1 names manifest traits stable individual differences in indicator levels, distinct from process-level `TRAITVAR` `φ_ξ`. Page 16 prints standardised matrices with the suffix `std` when appropriate. The printed example on p. 16 is `discreteDRIFTstd`, not `MANIFESTTRAITVARstd`. Footnote 4 standardises using only the relevant variance, not the total. The relevant variance for that named indicator-level correlation is `MANIFESTTRAITVAR`, not process-level `TRAITVAR` and not residual `MANIFESTVAR` `θ`. The 2017-era source forms `MANIFESTTRAITVARstd` only when `MANIFESTTRAITVAR != 0`, as `solve(sqrt(diag(MANIFESTTRAITVAR) + ridging)) %&% MANIFESTTRAITVAR` when `verbose = TRUE`. OpenMx `%&%` is `t(A) %*% B %*% A`. Unlike `TRAITVARstd`, that formation adds `diag(c(ridging), n.manifest)`. The default `ridging = FALSE` adds 0, not `0.0001`; that ridge is a numerical hack and is not this exact map. The scalar correlation is `ψ / ψ = 1` after strictly positive `MANIFESTTRAITVAR`. Form strictly positive `ψ` first, then `1 / √ψ`, then `(1 / √ψ) ψ (1 / √ψ)`. Unstandardised `MANIFESTTRAITVAR` is defined for a zero trait; standardised `MANIFESTTRAITVAR` is not. Zero `MANIFESTTRAITVAR` skips forming `MANIFESTTRAITVARstd` in the 2017-era source and fails closed here. Indicator-level trait variance is an event-time structural quantity, so a non-event clock fails closed. `MANIFESTTRAITVAR` does not require stable `a < 0`. Distinct positive `ψ` recover the same 1. `trait / trait = 1` is `TRAITVARstd` and recovers the same number and remains a distinct named quantity. `θ` is `MANIFESTVAR` and is measurement error, not this correlation. Meredith (1993) remains unread (web search 2026-08-27T14:20Z: Springer/Cambridge Core paywalled; Unpaywall historically `is_oa: false`; Springer `content/pdf` is an HTML stub). Mislevy (1991, *Psychometrika, 56*, 177–196) remains unread on the same terms (DOI `10.1007/bf02294457`). Still not a Kalman filter, not a matrix `expm`, not ESEM estimation, not DSEM, and not ctsem estimation.
diff --git a/Cargo.lock b/Cargo.lock
index 454a7d612..2a470ae5b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -78,6 +78,7 @@ dependencies = [
  "serde",
  "serde_json",
  "sha2",
+ "subevent_containment",
  "temporal_core",
  "tepp_api",
  "topic_measurement",
diff --git a/DOCUMENTATION.md b/DOCUMENTATION.md
index 6fa4b9683..60f65784a 100644
--- a/DOCUMENTATION.md
+++ b/DOCUMENTATION.md
@@ -71,6 +71,7 @@ TEPP's approved PRD v0.4 and implementation plan are the primary product baselin
 | Hourly NIM OpenCode doctoring | [`docs/doctoring/hourly-nim-opencode-development.md`](docs/doctoring/hourly-nim-opencode-development.md) |
 | Analysis engine v1 doctoring | [`docs/doctoring/analysis-engine-v1.md`](docs/doctoring/analysis-engine-v1.md) |
 | Analysis engine gap-closure doctoring | [`docs/doctoring/analysis-engine-gap-closure.md`](docs/doctoring/analysis-engine-gap-closure.md) |
+| Subevent-containment analysis-run doctoring | [`docs/doctoring/subevent-containment-analysis-run.md`](docs/doctoring/subevent-containment-analysis-run.md) |
 | Corpus-split leakage-audit wire doctoring | [`docs/research/corpus-split-manifest-wire.md`](docs/research/corpus-split-manifest-wire.md) |
 | Unicode canonical-identity doctoring | [`docs/research/unicode-canonical-identity.md`](docs/research/unicode-canonical-identity.md) |
 | Change history | [`CHANGELOG.md`](CHANGELOG.md) |
diff --git a/crates/analysis_engine/Cargo.toml b/crates/analysis_engine/Cargo.toml
index 7322212b2..f6ea2edd6 100644
--- a/crates/analysis_engine/Cargo.toml
+++ b/crates/analysis_engine/Cargo.toml
@@ -15,6 +15,7 @@ publish = false
 
 [dependencies]
 event_core = { path = "../event_core", version = "0.2.0" }
+subevent_containment = { path = "../subevent_containment", version = "0.2.0" }
 serde = { workspace = true }
 serde_json = { workspace = true }
 sha2 = { workspace = true }
diff --git a/crates/analysis_engine/src/lib.rs b/crates/analysis_engine/src/lib.rs
index 72bd5854c..239f7ef47 100644
--- a/crates/analysis_engine/src/lib.rs
+++ b/crates/analysis_engine/src/lib.rs
@@ -12,6 +12,7 @@
 
 mod case_deletion_refit;
 mod lineage_criterion;
+mod subevent_containment_artifact;
 mod topic_context_posterior;
 mod topic_lineage_artifact;
 
@@ -46,6 +47,13 @@ pub use lineage_criterion::{
     LineageCriterionFit, LineageCriterionFitError, LineageCriterionObservation,
     fit_lineage_criterion_posteriors,
 };
+/// Subevent-containment artifact and execution contracts from this engine.
+pub use subevent_containment_artifact::{
+    SUBEVENT_CONTAINMENT_ARTIFACT_BYTE_LIMIT, SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION,
+    SUBEVENT_CONTAINMENT_MODEL_CONTRACT_VERSION, SUBEVENT_CONTAINMENT_OUTPUT_PROFILE,
+    SubeventContainmentArtifact, SubeventContainmentAssignment, SubeventContainmentExecution,
+    execute_subevent_containment_run,
+};
 /// Bounded posterior topic-context producer contract and record types.
 pub use topic_context_posterior::{
     TOPIC_CONTEXT_POSTERIOR_BYTE_LIMIT, TOPIC_CONTEXT_POSTERIOR_SCHEMA_VERSION,
@@ -248,6 +256,8 @@ pub enum AnalysisEngineError {
     TopicMeasurement(TopicMeasurementError),
     /// A topic-lineage artifact violated its bounded schema or count invariants.
     InvalidTopicLineageArtifact,
+    /// A subevent-containment artifact violated its bounded schema or count invariants.
+    InvalidSubeventContainmentArtifact,
 }
 
 impl fmt::Display for AnalysisEngineError {
@@ -262,6 +272,7 @@ impl fmt::Display for AnalysisEngineError {
             Self::LimitExceeded => "analysis corpus exceeded its execution bound",
             Self::TopicMeasurement(error) => return error.fmt(formatter),
             Self::InvalidTopicLineageArtifact => "invalid topic lineage artifact",
+            Self::InvalidSubeventContainmentArtifact => "invalid subevent-containment artifact",
         };
         formatter.write_str(message)
     }
@@ -681,6 +692,10 @@ mod tests {
                 AnalysisEngineError::InvalidTopicLineageArtifact,
                 "invalid topic lineage artifact",
             ),
+            (
+                AnalysisEngineError::InvalidSubeventContainmentArtifact,
+                "invalid subevent-containment artifact",
+            ),
         ];
         for (error, message) in messages {
             assert_eq!(error.to_string(), message);
diff --git a/crates/analysis_engine/src/subevent_containment_artifact.rs b/crates/analysis_engine/src/subevent_containment_artifact.rs
new file mode 100644
index 000000000..427d6442c
--- /dev/null
+++ b/crates/analysis_engine/src/subevent_containment_artifact.rs
@@ -0,0 +1,411 @@
+//! Digest-bound subevent-containment refusals as an analysis-run profile.
+
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+use subevent_containment::{EventInterval, SubeventContainmentError, refuse_escaped_subevent};
+use temporal_core::{AvailableTime, KnowledgeCutoff};
+use tepp_api::{
+    AnalysisResultSummary, AnalysisRunAccepted, AnalysisRunRequest, AnalysisRunTerminalResult,
+};
+
+use crate::{
+    AnalysisEngineError, MAX_EVIDENCE_UNITS, format_digest, require_receipt_identity,
+    valid_identifier,
+};
+
+/// Versioned schema for a completed subevent-containment artifact.
+pub const SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION: &str = "tepp.subevent_containment.v1";
+/// Model contract required by the subevent-containment execution path.
+pub const SUBEVENT_CONTAINMENT_MODEL_CONTRACT_VERSION: &str = "subevent_containment_v1";
+/// Analysis-run output profile required for a subevent-containment artifact.
+pub const SUBEVENT_CONTAINMENT_OUTPUT_PROFILE: &str = "subevent_containment_v1";
+/// Maximum canonical artifact JSON size.
+pub const SUBEVENT_CONTAINMENT_ARTIFACT_BYTE_LIMIT: usize = 256 * 1024;
+const SUBEVENT_CONTAINMENT_INFERENCE_STATUS: &str =
+    "subevent_interval_cannot_escape_parent_interval";
+
+/// One cutoff-admitted child interval against a parent interval.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct SubeventContainmentAssignment {
+    assignment_id: String,
+    parent: EventInterval,
+    child: EventInterval,
+    available_time: AvailableTime,
+}
+
+impl SubeventContainmentAssignment {
+    /// Construct a bounded subevent-containment assignment.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`AnalysisEngineError::InvalidEvidence`] when the assignment
+    /// identity is empty or oversized.
+    pub fn new(
+        assignment_id: impl Into<String>,
+        parent: EventInterval,
+        child: EventInterval,
+        available_time: AvailableTime,
+    ) -> Result<Self, AnalysisEngineError> {
+        let assignment_id = assignment_id.into();
+        if !valid_identifier(&assignment_id) {
+            return Err(AnalysisEngineError::InvalidEvidence);
+        }
+        Ok(Self {
+            assignment_id,
+            parent,
+            child,
+            available_time,
+        })
+    }
+
+    /// Return the opaque assignment identity.
+    #[must_use]
+    pub fn assignment_id(&self) -> &str {
+        &self.assignment_id
+    }
+
+    /// Return the parent event-time interval.
+    #[must_use]
+    pub const fn parent(&self) -> EventInterval {
+        self.parent
+    }
+
+    /// Return the child subevent interval.
+    #[must_use]
+    pub const fn child(&self) -> EventInterval {
+        self.child
+    }
+
+    /// Return the availability time used for cutoff eligibility.
+    #[must_use]
+    pub const fn available_time(&self) -> AvailableTime {
+        self.available_time
+    }
+}
+
+/// Completed, bounded subevent-containment census for analysis-run clients.
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct SubeventContainmentArtifact {
+    /// Exact versioned schema identity.
+    pub schema_version: String,
+    /// Opaque accepted-run identity.
+    pub run_id: String,
+    /// Immutable source snapshot identity.
+    pub snapshot_id: String,
+    /// Historical evidence cutoff used to admit assignments.
+    pub knowledge_cutoff: String,
+    /// Number of assignments admitted at the cutoff.
+    pub assignment_count: u64,
+    /// Assignments contained in their parent interval.
+    pub contained_count: u64,
+    /// Assignments that escaped their parent interval.
+    pub escaped_count: u64,
+    /// Escaped assignments refused as subevent-outside-parent.
+    pub refused_as_escape_count: u64,
+    /// Fixed claim boundary for consumer copy.
+    pub inference_status: String,
+}
+
+impl SubeventContainmentArtifact {
+    /// Parse and fully validate a bounded artifact JSON payload.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`AnalysisEngineError::InvalidSubeventContainmentArtifact`] when
+    /// the schema, identifiers, counts, or claim boundary fail.
+    pub fn from_json(payload: &str) -> Result<Self, AnalysisEngineError> {
+        if payload.len() > SUBEVENT_CONTAINMENT_ARTIFACT_BYTE_LIMIT {
+            return Err(AnalysisEngineError::LimitExceeded);
+        }
+        let artifact: Self = serde_json::from_str(payload)
+            .map_err(|_| AnalysisEngineError::InvalidSubeventContainmentArtifact)?;
+        artifact.validate()?;
+        Ok(artifact)
+    }
+
+    /// Serialize canonical validated artifact JSON.
+    ///
+    /// # Errors
+    ///
+    /// Returns a typed validation, serialization, or size failure.
+    pub fn to_json(&self) -> Result<String, AnalysisEngineError> {
+        self.validate()?;
+        let payload =
+            serde_json::to_string(self).map_err(|_| AnalysisEngineError::SerializationFailure)?;
+        if payload.len() > SUBEVENT_CONTAINMENT_ARTIFACT_BYTE_LIMIT {
+            return Err(AnalysisEngineError::LimitExceeded);
+        }
+        Ok(payload)
+    }
+
+    /// Return the lowercase SHA-256 digest of canonical artifact JSON.
+    ///
+    /// # Errors
+    ///
+    /// Returns a typed validation or serialization failure.
+    pub fn sha256(&self) -> Result<String, AnalysisEngineError> {
+        self.to_json()
+            .map(|json| format_digest(Sha256::digest(json.into_bytes())))
+    }
+
+    fn validate(&self) -> Result<(), AnalysisEngineError> {
+        let status_sum = self.contained_count.checked_add(self.escaped_count);
+        if self.schema_version != SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION
+            || !valid_identifier(&self.run_id)
+            || !valid_identifier(&self.snapshot_id)
+            || KnowledgeCutoff::parse_rfc3339(&self.knowledge_cutoff).is_err()
+            || self.assignment_count < 2
+            || self.assignment_count > MAX_EVIDENCE_UNITS as u64
+            || self.contained_count == 0
+            || self.escaped_count == 0
+            || status_sum != Some(self.assignment_count)
+            || self.refused_as_escape_count != self.escaped_count
+            || self.inference_status != SUBEVENT_CONTAINMENT_INFERENCE_STATUS
+        {
+            return Err(AnalysisEngineError::InvalidSubeventContainmentArtifact);
+        }
+        Ok(())
+    }
+}
+
+/// One completed subevent-containment artifact and its terminal result.
+#[derive(Clone, Debug, PartialEq)]
+pub struct SubeventContainmentExecution {
+    /// Digest-bound completed subevent-containment census.
+    pub artifact: SubeventContainmentArtifact,
+    /// Terminal result carrying the artifact identity, digest, and schema.
+    pub terminal_result: AnalysisRunTerminalResult,
+}
+
+/// Execute cutoff-safe subevent-containment refusals as one analysis-run profile.
+///
+/// The executor invokes [`refuse_escaped_subevent`] already on protected
+/// main. Contained children stay attachments. Escaped children stay refusals,
+/// never episode-membership windows. It does not emit
+/// `identity_recovery_rate`, a `scientific_acceptance` inspect metric, GPU
+/// kernels, MCMC, or topic birth/split/merge events.
+///
+/// # Errors
+///
+/// Returns a request/receipt/snapshot/cutoff/profile error, empty or
+/// single-class corpus, inverted or escaped subevent treated as success,
+/// duplicate assignment identity, oversized corpus, or invalid artifact
+/// error.
+pub fn execute_subevent_containment_run(
+    request: &AnalysisRunRequest,
+    accepted: &AnalysisRunAccepted,
+    snapshot_id: &str,
+    knowledge_cutoff: KnowledgeCutoff,
+    assignments: &[SubeventContainmentAssignment],
+    completed_at: impl Into<String>,
+) -> Result<SubeventContainmentExecution, AnalysisEngineError> {
+    request.to_json()?;
+    accepted.to_json()?;
+    require_receipt_identity(request, accepted)?;
+    if request.snapshot_id != snapshot_id {
+        return Err(AnalysisEngineError::SnapshotMismatch);
+    }
+    let request_cutoff = KnowledgeCutoff::parse_rfc3339(&request.knowledge_cutoff)
+        .map_err(|_| AnalysisEngineError::InvalidEvidence)?;
+    if request_cutoff.instant() != knowledge_cutoff.instant()
+        || request.model_contract_version != SUBEVENT_CONTAINMENT_MODEL_CONTRACT_VERSION
+        || request.output_profile != SUBEVENT_CONTAINMENT_OUTPUT_PROFILE
+    {
+        return Err(AnalysisEngineError::InvalidEvidence);
+    }
+    if assignments.len() > MAX_EVIDENCE_UNITS {
+        return Err(AnalysisEngineError::LimitExceeded);
+    }
+
+    let (contained_count, escaped_count, refused_as_escape_count) =
+        census_assignments(assignments, knowledge_cutoff)?;
+    let assignment_count = contained_count
+        .checked_add(escaped_count)
+        .ok_or(AnalysisEngineError::ArithmeticOverflow)?;
+    if assignment_count < 2
+        || contained_count == 0
+        || escaped_count == 0
+        || refused_as_escape_count != escaped_count
+    {
+        return Err(AnalysisEngineError::InvalidEvidence);
+    }
+
+    let artifact = SubeventContainmentArtifact {
+        schema_version: SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION.into(),
+        run_id: accepted.run_id.clone(),
+        snapshot_id: snapshot_id.to_owned(),
+        knowledge_cutoff: knowledge_cutoff.to_rfc3339(),
+        assignment_count,
+        contained_count,
+        escaped_count,
+        refused_as_escape_count,
+        inference_status: SUBEVENT_CONTAINMENT_INFERENCE_STATUS.into(),
+    };
+    let digest = artifact.sha256()?;
+    let summary = AnalysisResultSummary::new(
+        "subevent_containment",
+        assignment_count,
+        4,
+        "validated",
+    )?;
+    let terminal_result = AnalysisRunTerminalResult::succeeded(
+        request,
+        accepted,
+        format!("subevent_containment_artifact_{}", &digest[..16]),
+        digest,
+        SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION,
+        completed_at,
+        summary,
+    )?;
+    Ok(SubeventContainmentExecution {
+        artifact,
+        terminal_result,
+    })
+}
+
+fn census_assignments(
+    assignments: &[SubeventContainmentAssignment],
+    knowledge_cutoff: KnowledgeCutoff,
+) -> Result<(u64, u64, u64), AnalysisEngineError> {
+    let mut seen = std::collections::BTreeSet::new();
+    let mut contained_count = 0_u64;
+    let mut escaped_count = 0_u64;
+    let mut refused_as_escape_count = 0_u64;
+    for assignment in assignments {
+        if !seen.insert(assignment.assignment_id()) {
+            return Err(AnalysisEngineError::DuplicateEvidence);
+        }
+        if assignment.available_time().instant() > knowledge_cutoff.instant() {
+            continue;
+        }
+        match refuse_escaped_subevent(assignment.parent(), assignment.child()) {
+            Ok(()) => {
+                contained_count = increment(contained_count)?;
+            }
+            Err(SubeventContainmentError::SubeventEscapesParent) => {
+                refused_as_escape_count = increment(refused_as_escape_count)?;
+                escaped_count = increment(escaped_count)?;
+            }
+            Err(SubeventContainmentError::InvalidIntervalPayload | _) => {
+                return Err(AnalysisEngineError::InvalidEvidence);
+            }
+        }
+    }
+    Ok((contained_count, escaped_count, refused_as_escape_count))
+}
+
+fn increment(count: u64) -> Result<u64, AnalysisEngineError> {
+    count
+        .checked_add(1)
+        .ok_or(AnalysisEngineError::ArithmeticOverflow)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        SUBEVENT_CONTAINMENT_ARTIFACT_BYTE_LIMIT, SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION,
+        SUBEVENT_CONTAINMENT_INFERENCE_STATUS, SubeventContainmentArtifact,
+    };
+    use crate::AnalysisEngineError;
+
+    fn artifact() -> SubeventContainmentArtifact {
+        SubeventContainmentArtifact {
+            schema_version: SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION.into(),
+            run_id: "run-1".into(),
+            snapshot_id: "snapshot-1".into(),
+            knowledge_cutoff: "2026-08-01T00:00:00Z".into(),
+            assignment_count: 2,
+            contained_count: 1,
+            escaped_count: 1,
+            refused_as_escape_count: 1,
+            inference_status: SUBEVENT_CONTAINMENT_INFERENCE_STATUS.into(),
+        }
+    }
+
+    fn assert_invalid(artifact: &SubeventContainmentArtifact) {
+        assert_eq!(
+            artifact.to_json(),
+            Err(AnalysisEngineError::InvalidSubeventContainmentArtifact)
+        );
+    }
+
+    #[test]
+    fn artifact_round_trip_and_size_bounds_fail_closed() {
+        let artifact = artifact();
+        let payload = artifact.to_json().expect("json");
+        assert_eq!(
+            SubeventContainmentArtifact::from_json(&payload),
+            Ok(artifact.clone())
+        );
+        assert_eq!(artifact.sha256().expect("digest").len(), 64);
+        assert_eq!(
+            SubeventContainmentArtifact::from_json("{}"),
+            Err(AnalysisEngineError::InvalidSubeventContainmentArtifact)
+        );
+        assert_eq!(
+            SubeventContainmentArtifact::from_json(
+                &"x".repeat(SUBEVENT_CONTAINMENT_ARTIFACT_BYTE_LIMIT + 1)
+            ),
+            Err(AnalysisEngineError::LimitExceeded)
+        );
+    }
+
+    #[test]
+    fn artifact_metadata_tampering_fails_closed() {
+        let artifact = artifact();
+        let invalid_artifacts = [
+            {
+                let mut value = artifact.clone();
+                value.schema_version.clear();
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.run_id.clear();
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.snapshot_id.clear();
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.knowledge_cutoff = "invalid".into();
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.assignment_count = 1;
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.contained_count = 0;
+                value.assignment_count = 1;
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.escaped_count = 0;
+                value.refused_as_escape_count = 0;
+                value.assignment_count = 1;
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.refused_as_escape_count = 0;
+                value
+            },
+            {
+                let mut value = artifact.clone();
+                value.inference_status.clear();
+                value
+            },
+        ];
+        for invalid in invalid_artifacts {
+            assert_invalid(&invalid);
+        }
+    }
+}
diff --git a/crates/analysis_engine/tests/subevent_containment_execution_contract.rs b/crates/analysis_engine/tests/subevent_containment_execution_contract.rs
new file mode 100644
index 000000000..98dbff773
--- /dev/null
+++ b/crates/analysis_engine/tests/subevent_containment_execution_contract.rs
@@ -0,0 +1,280 @@
+//! End-to-end contract for cutoff-safe subevent-containment refusals.
+
+use analysis_engine::{
+    AnalysisEngineError, MAX_EVIDENCE_UNITS, SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION,
+    SUBEVENT_CONTAINMENT_MODEL_CONTRACT_VERSION, SUBEVENT_CONTAINMENT_OUTPUT_PROFILE,
+    SubeventContainmentArtifact, SubeventContainmentAssignment, execute_subevent_containment_run,
+};
+use subevent_containment::EventInterval;
+use temporal_core::{AvailableTime, KnowledgeCutoff};
+use tepp_api::{AnalysisRunAccepted, AnalysisRunRequest, AnalysisRunTerminalState};
+
+fn cutoff() -> KnowledgeCutoff {
+    KnowledgeCutoff::parse_rfc3339("2026-08-01T00:00:00Z").expect("cutoff")
+}
+
+fn available(stamp: &str) -> AvailableTime {
+    AvailableTime::parse_rfc3339(stamp).expect("available")
+}
+
+fn interval(start: i64, end: i64) -> EventInterval {
+    EventInterval::new(start, end).expect("interval")
+}
+
+fn request() -> AnalysisRunRequest {
+    AnalysisRunRequest {
+        contract_version: 1,
+        idempotency_key: "subevent-containment-idem".into(),
+        tenant_workspace_id: "tenant-workspace".into(),
+        snapshot_id: "snapshot-subevent-containment".into(),
+        knowledge_cutoff: "2026-08-01T00:00:00Z".into(),
+        model_contract_version: SUBEVENT_CONTAINMENT_MODEL_CONTRACT_VERSION.into(),
+        output_profile: SUBEVENT_CONTAINMENT_OUTPUT_PROFILE.into(),
+    }
+}
+
+fn accepted(request: &AnalysisRunRequest) -> AnalysisRunAccepted {
+    AnalysisRunAccepted::new(
+        "run-subevent-containment",
+        "accepted",
+        &request.idempotency_key,
+    )
+    .expect("accepted")
+}
+
+fn assignment(
+    assignment_id: &str,
+    parent: EventInterval,
+    child: EventInterval,
+    stamp: &str,
+) -> SubeventContainmentAssignment {
+    SubeventContainmentAssignment::new(assignment_id, parent, child, available(stamp))
+        .expect("assignment")
+}
+
+fn mixed_assignments() -> Vec<SubeventContainmentAssignment> {
+    let parent = interval(10, 40);
+    vec![
+        assignment(
+            "contained-a",
+            parent,
+            interval(15, 30),
+            "2026-07-01T00:00:00Z",
+        ),
+        assignment("escaped-b", parent, interval(0, 20), "2026-07-02T00:00:00Z"),
+    ]
+}
+
+fn execute(
+    request: &AnalysisRunRequest,
+    assignments: &[SubeventContainmentAssignment],
+) -> Result<analysis_engine::SubeventContainmentExecution, AnalysisEngineError> {
+    execute_subevent_containment_run(
+        request,
+        &accepted(request),
+        "snapshot-subevent-containment",
+        cutoff(),
+        assignments,
+        "2026-08-02T00:00:00Z",
+    )
+}
+
+#[test]
+fn mixed_intervals_emit_digest_bound_refusals_without_recovery_metric() {
+    let request = request();
+    let execution = execute(&request, &mixed_assignments()).expect("execution");
+    assert_eq!(
+        execution.artifact.schema_version,
+        SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION
+    );
+    assert_eq!(execution.artifact.assignment_count, 2);
+    assert_eq!(execution.artifact.contained_count, 1);
+    assert_eq!(execution.artifact.escaped_count, 1);
+    assert_eq!(execution.artifact.refused_as_escape_count, 1);
+    assert_eq!(
+        execution.artifact.inference_status,
+        "subevent_interval_cannot_escape_parent_interval"
+    );
+    let payload = execution.artifact.to_json().expect("json");
+    assert!(!payload.contains("identity_recovery_rate"));
+    assert!(!payload.contains("scientific_acceptance"));
+    assert!(!payload.contains("episode_membership"));
+    assert_eq!(
+        execution.terminal_result.run_state,
+        AnalysisRunTerminalState::Succeeded
+    );
+    assert_eq!(
+        execution.terminal_result.result_sha256.as_deref(),
+        Some(execution.artifact.sha256().expect("digest").as_str())
+    );
+    assert_eq!(
+        execution.terminal_result.result_schema_version.as_deref(),
+        Some(SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION)
+    );
+}
+
+#[test]
+fn compact_oversized_artifact_counts_fail_closed() {
+    let assignment_count = MAX_EVIDENCE_UNITS as u64 + 1;
+    let escaped_count = assignment_count - 1;
+    let artifact = SubeventContainmentArtifact {
+        schema_version: SUBEVENT_CONTAINMENT_ARTIFACT_SCHEMA_VERSION.into(),
+        run_id: "run-compact-oversize".into(),
+        snapshot_id: "snapshot-compact-oversize".into(),
+        knowledge_cutoff: "2026-08-01T00:00:00Z".into(),
+        assignment_count,
+        contained_count: 1,
+        escaped_count,
+        refused_as_escape_count: escaped_count,
+        inference_status: "subevent_interval_cannot_escape_parent_interval".into(),
+    };
+    let raw_payload = serde_json::to_string(&artifact).expect("raw json");
+    assert_eq!(
+        artifact.to_json(),
+        Err(AnalysisEngineError::InvalidSubeventContainmentArtifact)
+    );
+    assert_eq!(
+        SubeventContainmentArtifact::from_json(&raw_payload),
+        Err(AnalysisEngineError::InvalidSubeventContainmentArtifact)
+    );
+}
+
+#[test]
+fn future_available_assignments_are_excluded() {
+    let request = request();
+    let parent = interval(10, 40);
+    let mut with_future = mixed_assignments();
+    with_future.push(assignment(
+        "future-c",
+        parent,
+        interval(15, 18),
+        "2026-08-02T00:00:00Z",
+    ));
+    let execution = execute(&request, &with_future).expect("cutoff");
+    assert_eq!(execution.artifact.assignment_count, 2);
+    assert_eq!(execution.artifact.contained_count, 1);
+}
+
+#[test]
+fn empty_or_single_class_and_duplicate_fail_closed() {
+    let request = request();
+    let parent = interval(10, 40);
+    let stamp = "2026-07-01T00:00:00Z";
+    assert_eq!(
+        execute(&request, &[]),
+        Err(AnalysisEngineError::InvalidEvidence)
+    );
+    let contained_only = vec![
+        assignment("contained-a", parent, interval(15, 18), stamp),
+        assignment("contained-b", parent, interval(20, 25), stamp),
+    ];
+    assert_eq!(
+        execute(&request, &contained_only),
+        Err(AnalysisEngineError::InvalidEvidence)
+    );
+    let escaped_only = vec![
+        assignment("escaped-a", parent, interval(0, 5), stamp),
+        assignment("escaped-b", parent, interval(40, 50), stamp),
+    ];
+    assert_eq!(
+        execute(&request, &escaped_only),
+        Err(AnalysisEngineError::InvalidEvidence)
+    );
+    let duplicates = vec![
+        assignment("same", parent, interval(15, 18), stamp),
+        assignment("same", parent, interval(0, 5), stamp),
+    ];
+    assert_eq!(
+        execute(&request, &duplicates),
+        Err(AnalysisEngineError::DuplicateEvidence)
+    );
+    assert_eq!(
+        SubeventContainmentAssignment::new("", parent, interval(15, 18), available(stamp)),
+        Err(AnalysisEngineError::InvalidEvidence)
+    );
+}
+
+#[test]
+fn execution_refuses_snapshot_profile_cutoff_mismatch_and_oversize() {
+    let request = request();
+    let assignments = mixed_assignments();
+    assert_eq!(
+        execute_subevent_containment_run(
+            &request,
+            &accepted(&request),
+            "other-snapshot",
+            cutoff(),
+            &assignments,
+            "2026-08-02T00:00:00Z",
+        ),
+        Err(AnalysisEngineError::SnapshotMismatch)
+    );
+    let mut mismatched = request.clone();
+    mismatched.knowledge_cutoff = "2026-07-01T00:00:00Z".into();
+    assert_eq!(
+        execute_subevent_containment_run(
+            &mismatched,
+            &accepted(&mismatched),
+            "snapshot-subevent-containment",
+            cutoff(),
+            &assignments,
+            "2026-08-02T00:00:00Z",
+        ),
+        Err(AnalysisEngineError::InvalidEvidence)
+    );
+    for profile in [
+        "trsl_topic_lineage_v1",
+        "fitted_candidate_k_v1",
+        "pareto_candidate_k_v1",
+        "joint_posterior_draws_v1",
+        "method_effects_v1",
+        "copy_identity_v1",
+        "style_source_v1",
+        "prompt_source_v1",
+        "modality_source_v1",
+        "corpus_background_v1",
+        "citation_edge_v1",
+        "copied_text_v1",
+        "lineage_criterion_v1",
+        "composed_fitted_lineage_v1",
+        "case_deletion_refit_v1",
+        "topic_activity_v1",
+        "location_membership_v1",
+        "topic_context_posterior_v1",
+        "membership_posterior_icc_v1",
+        "membership_target_v1",
+        "outcome_order_v1",
+        "relation_absence_v1",
+        "episode_membership_v1",
+        "inferred_status_v1",
+    ] {
+        let mut reused = request.clone();
+        reused.output_profile = profile.into();
+        assert_eq!(
+            execute_subevent_containment_run(
+                &reused,
+                &accepted(&reused),
+                "snapshot-subevent-containment",
+                cutoff(),
+                &assignments,
+                "2026-08-02T00:00:00Z",
+            ),
+            Err(AnalysisEngineError::InvalidEvidence)
+        );
+    }
+    let parent = interval(10, 40);
+    let oversized: Vec<SubeventContainmentAssignment> = (0..=MAX_EVIDENCE_UNITS)
+        .map(|index| {
+            assignment(
+                &format!("assignment-{index}"),
+                parent,
+                interval(15, 18),
+                "2026-07-01T00:00:00Z",
+            )
+        })
+        .collect();
+    assert_eq!(
+        execute(&request, &oversized),
+        Err(AnalysisEngineError::LimitExceeded)
+    );
+}
diff --git a/crates/analysis_engine/tests/subevent_containment_regression_contract.rs b/crates/analysis_engine/tests/subevent_containment_regression_contract.rs
new file mode 100644
index 000000000..032636793
--- /dev/null
+++ b/crates/analysis_engine/tests/subevent_containment_regression_contract.rs
@@ -0,0 +1,93 @@
+//! Regression contracts for subevent-containment analysis-run boundaries.
+
+use analysis_engine::{
+    SUBEVENT_CONTAINMENT_MODEL_CONTRACT_VERSION, SUBEVENT_CONTAINMENT_OUTPUT_PROFILE,
+    SubeventContainmentAssignment, execute_subevent_containment_run,
+};
+use subevent_containment::EventInterval;
+use temporal_core::{AvailableTime, KnowledgeCutoff};
+use tepp_api::{AnalysisRunAccepted, AnalysisRunRequest};
+
+fn interval(start: i64, end: i64) -> EventInterval {
+    EventInterval::new(start, end).expect("interval")
+}
+
+fn available(stamp: &str) -> AvailableTime {
+    AvailableTime::parse_rfc3339(stamp).expect("available time")
+}
+
+fn request(cutoff: &str) -> AnalysisRunRequest {
+    AnalysisRunRequest {
+        contract_version: 1,
+        idempotency_key: "subevent-containment-regression".into(),
+        tenant_workspace_id: "tenant-workspace".into(),
+        snapshot_id: "snapshot-subevent-containment".into(),
+        knowledge_cutoff: cutoff.into(),
+        model_contract_version: SUBEVENT_CONTAINMENT_MODEL_CONTRACT_VERSION.into(),
+        output_profile: SUBEVENT_CONTAINMENT_OUTPUT_PROFILE.into(),
+    }
+}
+
+fn accepted(request: &AnalysisRunRequest) -> AnalysisRunAccepted {
+    AnalysisRunAccepted::new("run-subevent-containment", "accepted", &request.idempotency_key)
+        .expect("accepted")
+}
+
+fn assignments() -> Vec<SubeventContainmentAssignment> {
+    let parent = interval(10, 40);
+    vec![
+        SubeventContainmentAssignment::new(
+            "contained",
+            parent,
+            interval(15, 30),
+            available("2026-07-01T00:00:00Z"),
+        )
+        .expect("contained assignment"),
+        SubeventContainmentAssignment::new(
+            "escaped",
+            parent,
+            interval(0, 20),
+            available("2026-07-02T00:00:00Z"),
+        )
+        .expect("escaped assignment"),
+    ]
+}
+
+#[test]
+fn equivalent_rfc3339_cutoff_spellings_bind_to_the_same_instant() {
+    let request = request("2026-08-01T09:00:00+09:00");
+    let execution = execute_subevent_containment_run(
+        &request,
+        &accepted(&request),
+        "snapshot-subevent-containment",
+        KnowledgeCutoff::parse_rfc3339("2026-08-01T00:00:00Z").expect("cutoff"),
+        &assignments(),
+        "2026-08-02T00:00:00Z",
+    )
+    .expect("equivalent cutoff instants must bind");
+    assert_eq!(execution.artifact.assignment_count, 2);
+}
+
+#[test]
+fn terminal_summary_keeps_validation_state_separate_from_inference_status() {
+    let request = request("2026-08-01T00:00:00Z");
+    let execution = execute_subevent_containment_run(
+        &request,
+        &accepted(&request),
+        "snapshot-subevent-containment",
+        KnowledgeCutoff::parse_rfc3339("2026-08-01T00:00:00Z").expect("cutoff"),
+        &assignments(),
+        "2026-08-02T00:00:00Z",
+    )
+    .expect("execution");
+    let summary = execution
+        .terminal_result
+        .summary
+        .as_ref()
+        .expect("succeeded summary");
+    assert_eq!(summary.validation_status, "validated");
+    assert_eq!(
+        execution.artifact.inference_status,
+        "subevent_interval_cannot_escape_parent_interval"
+    );
+}
diff --git a/docs/TRACEABILITY.md b/docs/TRACEABILITY.md
index 2b783c2ab..f8cf87fd3 100644
--- a/docs/TRACEABILITY.md
+++ b/docs/TRACEABILITY.md
@@ -58,6 +58,7 @@ The full APA 7th standards/literature register remains `docs/research/standards-
 | versioned service/API contracts and exports | PRD; API contract; ADR 0011/0013 | `tepp_api` analysis-run/export/JSON-LD/GraphML contracts on protected main (PR #21); HTTP service remaining accepted-target | partial |
 | versioned service/API contracts and exports | PRD; API contract; ADR 0011/0013 | `tepp_api` analysis-run/export/JSON-LD/GraphML contracts on protected main (PR #21); LineageWeave loopback contracts and request-bound terminal result are composed on the active product branch; production TLS remaining | partial |
 | executable cutoff-safe analysis runs | ADR 0012/0022; temporal research; API terminal-result contract | `analysis_engine` availability cutoff, snapshot binding, multiple-membership aggregation, digest-bound readiness artifact, and `tepp.trsl_topic_lineage.v1` execution through `topic_measurement`; synthetic recovery plus tamper/non-convergence tests and exact coverage on the active product branch | active-PR |
+| subevent-containment analysis-run profile | ADR 0003/0022/0074; subevent intervals cannot escape the parent interval | `analysis_engine` `subevent_containment_v1` binds `refuse_escaped_subevent`; digest-bound refusals, not `identity_recovery_rate` inspect metric, not episode-membership, not inferred-status, not relation-absence, not outcome-order, not membership-target, not location-membership, not GPU, not MCMC, not topic birth/split/merge; not implemented-main | active-PR |
 | immutable split/run/reproducibility manifests | ADR 0013; ERD | `tepp_api` reproducibility manifest contract on protected main; `persistence_postgres` append-only SQL insert/lookup for `reproducibility_manifest`, `corpus_split_manifest`, `model_run`, and `model_artifact` (migration `0003`); full physical ERD constraints remaining | partial |
 | multilingual shared latent semantic space | PRD; ADR 0004; ADR 0020 | `semantic_core` span-grounded units (active-PR); concept dictionary and shared latent estimator remaining | active-PR |
 | TRSL-TM temporal/relational topic posterior and backend compatibility | ADR 0012; ADR 0004 | `topic_measurement` stable ALR/ILR coordinates and bounded CPU `f64` reference estimator on protected main; `model_selection` fitted candidate-`K` scoring on this PR; calibrated posterior promotion, method effects, persistence, and accelerated backends remaining | partial |
diff --git a/docs/adr/0074-subevent-containment-analysis-run.md b/docs/adr/0074-subevent-containment-analysis-run.md
new file mode 100644
index 000000000..5e1289045
--- /dev/null
+++ b/docs/adr/0074-subevent-containment-analysis-run.md
@@ -0,0 +1,108 @@
+# ADR 0074 — Subevent-containment refusals as an analysis-run output profile
+
+**Decision status:** Accepted
+**Implementation maturity:** active-PR — composed on this branch; not implemented-main
+**Date:** 2026-09-02
+**Supersedes:** None; complements ADR 0003 (a subevent interval cannot escape the parent event-time interval) and ADR 0022 (cutoff-safe analysis-run execution). Does not reuse ADR 0073 (inferred-status), ADR 0072 (episode-membership), ADR 0071 (relation-absence), ADR 0070 (outcome-order), ADR 0069 (membership-target), ADR 0068 (topic-context posterior), ADR 0066 (location-membership), ADR 0065 (copied-text residue), ADR 0064 (provenance-is-not-transition / citation-edge), or ADR 0058 (copy-identity / template-copy). This is subevent-versus-parent containment, not episode-membership-window containment.
+**Figma File ID:** N/A — this increment changes a Rust service crate and has no user-interface surface.
+**Storybook inventory:** N/A — no reusable web object or interaction changed.
+
+## Context
+
+Protected main already refuses a half-open subevent interval that starts
+before or ends after its parent, via `subevent_containment::EventInterval`
+and `refuse_escaped_subevent`. Operators still cannot request that census
+as a digest-bound analysis-run output.
+
+Episode-membership (#461 / ADR 0072) binds membership windows to episode
+intervals. Inferred-status (#473 / ADR 0073) binds inferred-versus-observed
+refusals. Relation-absence (#460 / ADR 0071) binds observation status.
+Outcome-order (#458 / ADR 0070) binds IPO event-time order.
+Membership-target (#434 / ADR 0069) binds `MembershipTargetKind`.
+Location-membership (#430 / ADR 0066) binds geographic/market assignment.
+
+`containment_recovery_rate` and `identity_recovery_rate` stay library-side.
+This slice does not put a `scientific_acceptance` metric on inspect
+payloads. Episode-window containment remains `episode_membership`.
+
+GPU kernels, MCMC, and topic birth/split/merge remain later GAP-004 work
+and are not this slice.
+
+## Decision
+
+Add the `subevent_containment_v1` analysis-run output profile to
+`analysis_engine`. The executor:
+
+- consumes already-validated `SubeventContainmentAssignment` rows with
+  half-open `EventInterval` parent/child bounds and availability time;
+- requires the request snapshot and knowledge cutoff to match the offered
+  input construction;
+- excludes assignments whose availability is later than the knowledge
+  cutoff;
+- invokes `refuse_escaped_subevent` without reimplementing the
+  containment vocabulary;
+- requires a mixed census of at least one contained and one escaped
+  assignment after cutoff exclusion;
+- emits a canonical SHA-256-digested `tepp.subevent_containment.v1` artifact
+  with contained/escaped counts, matching escape-refusal counts, and
+  inference status `subevent_interval_cannot_escape_parent_interval`;
+- does not emit `identity_recovery_rate`, invent MCMC, select GPU
+  backends, or emit topic birth/split/merge events.
+
+## Alternatives considered
+
+1. Duplicate episode-membership (#461 / ADR 0072) — rejected because that
+   profile binds membership windows to episode intervals, not
+   subevent-versus-parent containment.
+2. Duplicate inferred-status (#473 / ADR 0073) — rejected because that
+   profile binds inferred-versus-observed status.
+3. Duplicate relation-absence (#460 / ADR 0071) — rejected because that
+   profile binds observation status.
+4. Duplicate outcome-order (#458 / ADR 0070) — rejected because that
+   profile binds IPO event-time order.
+5. Duplicate membership-target (#434 / ADR 0069) — rejected because that
+   profile binds `MembershipTargetKind`.
+6. Duplicate location-membership (#430 / ADR 0066) — rejected because
+   that profile binds `location_membership` LocationKind refusals.
+7. Put `containment_recovery_rate` or `identity_recovery_rate` on the
+   operator artifact — rejected because inspect payloads stay metric-free
+   and `tepp.scientific_acceptance.v1` never appears.
+8. Bind the existing subevent-containment refusals to ADR 0022's
+   analysis-run profile — accepted.
+
+## Consequences
+
+Operators can request cutoff-safe subevent-containment refusals as a
+digest-bound terminal result. The artifact does not claim MCMC, GPU
+parity, episode-membership, inferred-status, relation-absence,
+outcome-order, membership-target, location-membership,
+membership-posterior ICC, copied-text, copy-identity, citation-edge,
+method-effect estimation, or topic birth/split/merge. Snapshot / profile
+/ cutoff mismatch, empty or single-class corpora, duplicate assignment
+identities, and oversized corpora fail closed.
+
+## Verification
+
+The PR includes Rust unit and integration tests for mixed
+contained/escaped corpora, cutoff exclusion, empty/single-class/duplicate
+refusal, snapshot / profile / cutoff mismatch, oversize, compact
+`MAX_EVIDENCE_UNITS + 1` artifact refusal, and artifact tampering. Run:
+
+```text
+cargo fmt --all -- --check
+cargo test -p analysis_engine
+cargo clippy -p analysis_engine --all-targets -- -D warnings
+python3 scripts/validate_documentation.py
+```
+
+Exact-head hosted Rust Foundation CI, Documentation Quality, Security
+Scan, and SAST Semgrep on this branch head are required landing evidence.
+Predecessor-head checks do not transfer.
+
+## Rollback and supersession
+
+Rollback removes the `subevent_containment_v1` profile. No persisted schema
+migration is introduced. Supersede only with an ADR that keeps subevent
+intervals inside the parent interval, keeps this distinct from
+episode-membership-window containment, and keeps recovery rates off
+inspect payloads.
diff --git a/docs/adr/README.md b/docs/adr/README.md
index 1254c8079..1297aaf33 100644
--- a/docs/adr/README.md
+++ b/docs/adr/README.md
@@ -28,6 +28,7 @@ Read [`ADR_POLICY.md`](ADR_POLICY.md) first. **Decision status and implementatio
 | [0020](0020-span-grounded-semantic-units.md) | Span-grounded semantic units; language tags are not identity | Accepted | active-PR | First ADR 0004 production slice; concept alignment, invariance, and topic estimation are not claimed. |
 | [0021](0021-lineageweave-project-history-boundary.md) | LineageWeave project-history service boundary | Accepted | active-PR | Credential-free bounded project-history API preserves LineageWeave authorization ownership. |
 | [0022](0022-deterministic-analysis-run-execution.md) | Deterministic cutoff-safe analysis-run execution | Accepted | active-PR | Closes the first executable product path from accepted run to digest-bound terminal result without claiming estimator authority. |
+| [0074](0074-subevent-containment-analysis-run.md) | Subevent-containment refusals as an analysis-run profile | Accepted | active-PR | Complements ADR 0003/0022; `EventInterval` + `refuse_escaped_subevent`, not episode-membership, not inferred-status. |
 | [0024](0024-lineage-pair-criterion-and-project-journey-posterior.md) | Independent Event Lineage pair criterion and posterior Project Journey | Proposed | active-PR | Strict artifacts preserve criterion/event-time draws, branches, ties, and CPU/GPU receipts without claiming the scientific estimator is complete. |
 | [0025](0025-macos-native-rust-mlx-metal-boundary.md) | macOS-native Rust-owned MLX Metal execution | Accepted | accepted-target | Compose authenticates to a native host service; Linux never claims Metal, and actual backend/parity receipts fail closed. |
 | [0023](0023-lineage-criterion-anchor-contract.md) | TEPP-owned Event Lineage criterion anchor | Accepted | active-PR | PR #237 publishes the strict accepted/rejected artifact and identities; estimator execution remains fail-closed future work. |
@@ -138,6 +139,7 @@ Use the narrowest owning ADR when decisions overlap:
 - **project-history wire-size symmetry:** ADR 0019.
 - **LineageWeave project-history service boundary:** ADR 0021.
 - **accepted-run execution and terminal artifact production:** ADR 0022.
+- **subevent-containment analysis-run profile:** ADR 0074.
 - **independent lineage criterion and posterior Project Journey:** ADR 0023.
 - **macOS-native Rust-owned MLX Metal execution:** ADR 0024.
 
diff --git a/docs/doctoring/subevent-containment-analysis-run.md b/docs/doctoring/subevent-containment-analysis-run.md
new file mode 100644
index 000000000..01861deaa
--- /dev/null
+++ b/docs/doctoring/subevent-containment-analysis-run.md
@@ -0,0 +1,19 @@
+# Subevent-containment analysis-run composition
+
+**Active slice:** ADR 0074 / `subevent_containment_v1`
+**Protected-main status:** not implemented-main
+
+`subevent_containment` already refuses a half-open child interval that
+starts before or ends after its parent. This slice binds `EventInterval`
+and `refuse_escaped_subevent` to a cutoff-safe analysis-run profile so
+operators can request a digest-bound identity artifact.
+
+The artifact inference status is
+`subevent_interval_cannot_escape_parent_interval`.
+`containment_recovery_rate` and `identity_recovery_rate` stay
+library-side. This is subevent-versus-parent containment, not
+episode-membership-window containment. This is not inferred-status, not
+relation-absence, not outcome-order, not membership-target, not
+location-membership, not membership-posterior ICC, not copied-text, not
+copy-identity, not citation-edge, not GPU, not MCMC, and not topic
+birth/split/merge.